# Generated from src/cypher_subgraph/Cypher.g4 by ANTLR 4.7.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
from typing.io import TextIO
import sys

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

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

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

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

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

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



    class OC_CypherContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Cypher" ):
                return visitor.visitOC_Cypher(self)
            else:
                return visitor.visitChildren(self)




    def oC_Cypher(self):

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


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


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


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


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

    class OC_StatementContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Statement" ):
                return visitor.visitOC_Statement(self)
            else:
                return visitor.visitChildren(self)




    def oC_Statement(self):

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

    class OC_QueryContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Query

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




    def oC_Query(self):

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

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


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

    class OC_RegularQueryContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RegularQuery" ):
                return visitor.visitOC_RegularQuery(self)
            else:
                return visitor.visitChildren(self)




    def oC_RegularQuery(self):

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


                    self.state = 225
                    self.oC_Union() 
                self.state = 230
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)

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

    class OC_UnionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Union" ):
                return visitor.visitOC_Union(self)
            else:
                return visitor.visitChildren(self)




    def oC_Union(self):

        localctx = CypherParser.OC_UnionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_oC_Union)
        self._la = 0 # Token type
        try:
            self.state = 243
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 231
                self.match(CypherParser.UNION)
                self.state = 232
                self.match(CypherParser.SP)
                self.state = 233
                self.match(CypherParser.ALL)
                self.state = 235
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 234
                    self.match(CypherParser.SP)


                self.state = 237
                self.oC_SingleQuery()
                pass

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


                self.state = 242
                self.oC_SingleQuery()
                pass


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

    class OC_SingleQueryContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_SingleQuery" ):
                return visitor.visitOC_SingleQuery(self)
            else:
                return visitor.visitChildren(self)




    def oC_SingleQuery(self):

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

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


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

    class OC_SinglePartQueryContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_SinglePartQuery" ):
                return visitor.visitOC_SinglePartQuery(self)
            else:
                return visitor.visitChildren(self)




    def oC_SinglePartQuery(self):

        localctx = CypherParser.OC_SinglePartQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_oC_SinglePartQuery)
        self._la = 0 # Token type
        try:
            self.state = 284
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.CALL))) != 0):
                    self.state = 249
                    self.oC_ReadingClause()
                    self.state = 251
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 250
                        self.match(CypherParser.SP)


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

                self.state = 258
                self.oC_Return()
                pass

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


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

                self.state = 268
                self.oC_UpdatingClause()
                self.state = 275
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,16,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 270
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 269
                            self.match(CypherParser.SP)


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

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


                    self.state = 281
                    self.oC_Return()


                pass


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

    class OC_MultiPartQueryContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_MultiPartQuery" ):
                return visitor.visitOC_MultiPartQuery(self)
            else:
                return visitor.visitChildren(self)




    def oC_MultiPartQuery(self):

        localctx = CypherParser.OC_MultiPartQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_oC_MultiPartQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 292
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.CALL))) != 0):
                        self.state = 286
                        self.oC_ReadingClause()
                        self.state = 288
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 287
                            self.match(CypherParser.SP)


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

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


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

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



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

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

    class OC_UpdatingClauseContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_UpdatingClause" ):
                return visitor.visitOC_UpdatingClause(self)
            else:
                return visitor.visitChildren(self)




    def oC_UpdatingClause(self):

        localctx = CypherParser.OC_UpdatingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_oC_UpdatingClause)
        try:
            self.state = 319
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.CREATE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 314
                self.oC_Create()
                pass
            elif token in [CypherParser.MERGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 315
                self.oC_Merge()
                pass
            elif token in [CypherParser.DETACH, CypherParser.DELETE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 316
                self.oC_Delete()
                pass
            elif token in [CypherParser.SET]:
                self.enterOuterAlt(localctx, 4)
                self.state = 317
                self.oC_Set()
                pass
            elif token in [CypherParser.REMOVE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 318
                self.oC_Remove()
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_ReadingClauseContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ReadingClause" ):
                return visitor.visitOC_ReadingClause(self)
            else:
                return visitor.visitChildren(self)




    def oC_ReadingClause(self):

        localctx = CypherParser.OC_ReadingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_oC_ReadingClause)
        try:
            self.state = 324
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.OPTIONAL, CypherParser.MATCH]:
                self.enterOuterAlt(localctx, 1)
                self.state = 321
                self.oC_Match()
                pass
            elif token in [CypherParser.UNWIND]:
                self.enterOuterAlt(localctx, 2)
                self.state = 322
                self.oC_Unwind()
                pass
            elif token in [CypherParser.CALL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 323
                self.oC_InQueryCall()
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_MatchContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Match" ):
                return visitor.visitOC_Match(self)
            else:
                return visitor.visitChildren(self)




    def oC_Match(self):

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


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


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


                self.state = 338
                self.oC_Where()


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

    class OC_UnwindContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Unwind" ):
                return visitor.visitOC_Unwind(self)
            else:
                return visitor.visitChildren(self)




    def oC_Unwind(self):

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


            self.state = 345
            self.oC_Expression()
            self.state = 346
            self.match(CypherParser.SP)
            self.state = 347
            self.match(CypherParser.AS)
            self.state = 348
            self.match(CypherParser.SP)
            self.state = 349
            self.oC_Variable()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_MergeContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Merge" ):
                return visitor.visitOC_Merge(self)
            else:
                return visitor.visitChildren(self)




    def oC_Merge(self):

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


            self.state = 355
            self.oC_PatternPart()
            self.state = 360
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 356
                    self.match(CypherParser.SP)
                    self.state = 357
                    self.oC_MergeAction() 
                self.state = 362
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

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

    class OC_MergeActionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_MergeAction" ):
                return visitor.visitOC_MergeAction(self)
            else:
                return visitor.visitChildren(self)




    def oC_MergeAction(self):

        localctx = CypherParser.OC_MergeActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_oC_MergeAction)
        try:
            self.state = 373
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 363
                self.match(CypherParser.ON)
                self.state = 364
                self.match(CypherParser.SP)
                self.state = 365
                self.match(CypherParser.MATCH)
                self.state = 366
                self.match(CypherParser.SP)
                self.state = 367
                self.oC_Set()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 368
                self.match(CypherParser.ON)
                self.state = 369
                self.match(CypherParser.SP)
                self.state = 370
                self.match(CypherParser.CREATE)
                self.state = 371
                self.match(CypherParser.SP)
                self.state = 372
                self.oC_Set()
                pass


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

    class OC_CreateContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Create" ):
                return visitor.visitOC_Create(self)
            else:
                return visitor.visitChildren(self)




    def oC_Create(self):

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


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

    class OC_SetContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Set" ):
                return visitor.visitOC_Set(self)
            else:
                return visitor.visitChildren(self)




    def oC_Set(self):

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


            self.state = 385
            self.oC_SetItem()
            self.state = 396
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 387
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 386
                        self.match(CypherParser.SP)


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


                    self.state = 393
                    self.oC_SetItem() 
                self.state = 398
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,40,self._ctx)

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

    class OC_SetItemContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_SetItem" ):
                return visitor.visitOC_SetItem(self)
            else:
                return visitor.visitChildren(self)




    def oC_SetItem(self):

        localctx = CypherParser.OC_SetItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_oC_SetItem)
        self._la = 0 # Token type
        try:
            self.state = 435
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 399
                self.oC_PropertyExpression()
                self.state = 401
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 400
                    self.match(CypherParser.SP)


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


                self.state = 407
                self.oC_Expression()
                pass

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


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


                self.state = 417
                self.oC_Expression()
                pass

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


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


                self.state = 427
                self.oC_Expression()
                pass

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


                self.state = 433
                self.oC_NodeLabels()
                pass


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

    class OC_DeleteContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Delete" ):
                return visitor.visitOC_Delete(self)
            else:
                return visitor.visitChildren(self)




    def oC_Delete(self):

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


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


            self.state = 445
            self.oC_Expression()
            self.state = 456
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,53,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 447
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 446
                        self.match(CypherParser.SP)


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


                    self.state = 453
                    self.oC_Expression() 
                self.state = 458
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,53,self._ctx)

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

    class OC_RemoveContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Remove" ):
                return visitor.visitOC_Remove(self)
            else:
                return visitor.visitChildren(self)




    def oC_Remove(self):

        localctx = CypherParser.OC_RemoveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_oC_Remove)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self.match(CypherParser.REMOVE)
            self.state = 460
            self.match(CypherParser.SP)
            self.state = 461
            self.oC_RemoveItem()
            self.state = 472
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,56,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 463
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 462
                        self.match(CypherParser.SP)


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


                    self.state = 469
                    self.oC_RemoveItem() 
                self.state = 474
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,56,self._ctx)

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

    class OC_RemoveItemContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RemoveItem" ):
                return visitor.visitOC_RemoveItem(self)
            else:
                return visitor.visitChildren(self)




    def oC_RemoveItem(self):

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

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 478
                self.oC_PropertyExpression()
                pass


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

    class OC_InQueryCallContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_InQueryCall" ):
                return visitor.visitOC_InQueryCall(self)
            else:
                return visitor.visitChildren(self)




    def oC_InQueryCall(self):

        localctx = CypherParser.OC_InQueryCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_oC_InQueryCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 481
            self.match(CypherParser.CALL)
            self.state = 482
            self.match(CypherParser.SP)
            self.state = 483
            self.oC_ExplicitProcedureInvocation()
            self.state = 490
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 485
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 484
                    self.match(CypherParser.SP)


                self.state = 487
                self.match(CypherParser.YIELD)
                self.state = 488
                self.match(CypherParser.SP)
                self.state = 489
                self.oC_YieldItems()


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

    class OC_StandaloneCallContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_StandaloneCall" ):
                return visitor.visitOC_StandaloneCall(self)
            else:
                return visitor.visitChildren(self)




    def oC_StandaloneCall(self):

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

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


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


                self.state = 501
                self.match(CypherParser.YIELD)
                self.state = 502
                self.match(CypherParser.SP)
                self.state = 505
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CypherParser.T__4]:
                    self.state = 503
                    self.match(CypherParser.T__4)
                    pass
                elif token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                    self.state = 504
                    self.oC_YieldItems()
                    pass
                else:
                    raise NoViableAltException(self)



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

    class OC_YieldItemsContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_YieldItems" ):
                return visitor.visitOC_YieldItems(self)
            else:
                return visitor.visitChildren(self)




    def oC_YieldItems(self):

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


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


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

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


                self.state = 526
                self.oC_Where()


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

    class OC_YieldItemContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_YieldItem" ):
                return visitor.visitOC_YieldItem(self)
            else:
                return visitor.visitChildren(self)




    def oC_YieldItem(self):

        localctx = CypherParser.OC_YieldItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_oC_YieldItem)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 534
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 529
                self.oC_ProcedureResultField()
                self.state = 530
                self.match(CypherParser.SP)
                self.state = 531
                self.match(CypherParser.AS)
                self.state = 532
                self.match(CypherParser.SP)


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

    class OC_WithContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_With" ):
                return visitor.visitOC_With(self)
            else:
                return visitor.visitChildren(self)




    def oC_With(self):

        localctx = CypherParser.OC_WithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_oC_With)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self.match(CypherParser.WITH)
            self.state = 539
            self.oC_ProjectionBody()
            self.state = 544
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 541
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 540
                    self.match(CypherParser.SP)


                self.state = 543
                self.oC_Where()


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

    class OC_ReturnContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Return" ):
                return visitor.visitOC_Return(self)
            else:
                return visitor.visitChildren(self)




    def oC_Return(self):

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

    class OC_ProjectionBodyContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ProjectionBody" ):
                return visitor.visitOC_ProjectionBody(self)
            else:
                return visitor.visitChildren(self)




    def oC_ProjectionBody(self):

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


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


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


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


            self.state = 567
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 565
                self.match(CypherParser.SP)
                self.state = 566
                self.oC_Limit()


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

    class OC_ProjectionItemsContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ProjectionItems" ):
                return visitor.visitOC_ProjectionItems(self)
            else:
                return visitor.visitChildren(self)




    def oC_ProjectionItems(self):

        localctx = CypherParser.OC_ProjectionItemsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_oC_ProjectionItems)
        self._la = 0 # Token type
        try:
            self.state = 597
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 569
                self.match(CypherParser.T__4)
                self.state = 580
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,79,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 571
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 570
                            self.match(CypherParser.SP)


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


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

                pass
            elif token in [CypherParser.T__5, CypherParser.T__7, CypherParser.T__12, CypherParser.T__13, CypherParser.T__22, CypherParser.T__25, CypherParser.ALL, CypherParser.NOT, CypherParser.NULL, CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.TRUE, CypherParser.FALSE, CypherParser.EXISTS, CypherParser.CASE, CypherParser.StringLiteral, CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger, CypherParser.HexLetter, CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 2)
                self.state = 583
                self.oC_ProjectionItem()
                self.state = 594
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,82,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 585
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 584
                            self.match(CypherParser.SP)


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


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

                pass
            else:
                raise NoViableAltException(self)

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

    class OC_ProjectionItemContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ProjectionItem" ):
                return visitor.visitOC_ProjectionItem(self)
            else:
                return visitor.visitChildren(self)




    def oC_ProjectionItem(self):

        localctx = CypherParser.OC_ProjectionItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_oC_ProjectionItem)
        try:
            self.state = 606
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 599
                self.oC_Expression()
                self.state = 600
                self.match(CypherParser.SP)
                self.state = 601
                self.match(CypherParser.AS)
                self.state = 602
                self.match(CypherParser.SP)
                self.state = 603
                self.oC_Variable()
                pass

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


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

    class OC_OrderContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Order" ):
                return visitor.visitOC_Order(self)
            else:
                return visitor.visitChildren(self)




    def oC_Order(self):

        localctx = CypherParser.OC_OrderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_oC_Order)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 608
            self.match(CypherParser.ORDER)
            self.state = 609
            self.match(CypherParser.SP)
            self.state = 610
            self.match(CypherParser.BY)
            self.state = 611
            self.match(CypherParser.SP)
            self.state = 612
            self.oC_SortItem()
            self.state = 620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.T__1:
                self.state = 613
                self.match(CypherParser.T__1)
                self.state = 615
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 614
                    self.match(CypherParser.SP)


                self.state = 617
                self.oC_SortItem()
                self.state = 622
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class OC_SkipContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Skip" ):
                return visitor.visitOC_Skip(self)
            else:
                return visitor.visitChildren(self)




    def oC_Skip(self):

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

    class OC_LimitContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Limit" ):
                return visitor.visitOC_Limit(self)
            else:
                return visitor.visitChildren(self)




    def oC_Limit(self):

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

    class OC_SortItemContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_SortItem" ):
                return visitor.visitOC_SortItem(self)
            else:
                return visitor.visitChildren(self)




    def oC_SortItem(self):

        localctx = CypherParser.OC_SortItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_oC_SortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self.oC_Expression()
            self.state = 636
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
            if la_ == 1:
                self.state = 633
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 632
                    self.match(CypherParser.SP)


                self.state = 635
                _la = self._input.LA(1)
                if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (CypherParser.ASCENDING - 68)) | (1 << (CypherParser.ASC - 68)) | (1 << (CypherParser.DESCENDING - 68)) | (1 << (CypherParser.DESC - 68)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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

    class OC_WhereContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Where" ):
                return visitor.visitOC_Where(self)
            else:
                return visitor.visitChildren(self)




    def oC_Where(self):

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

    class OC_PatternContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Pattern" ):
                return visitor.visitOC_Pattern(self)
            else:
                return visitor.visitChildren(self)




    def oC_Pattern(self):

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


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


                    self.state = 650
                    self.oC_PatternPart() 
                self.state = 655
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,91,self._ctx)

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

    class OC_PatternPartContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PatternPart" ):
                return visitor.visitOC_PatternPart(self)
            else:
                return visitor.visitChildren(self)




    def oC_PatternPart(self):

        localctx = CypherParser.OC_PatternPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_oC_PatternPart)
        self._la = 0 # Token type
        try:
            self.state = 667
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 1)
                self.state = 656
                self.oC_Variable()
                self.state = 658
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 657
                    self.match(CypherParser.SP)


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


                self.state = 664
                self.oC_AnonymousPatternPart()
                pass
            elif token in [CypherParser.T__5]:
                self.enterOuterAlt(localctx, 2)
                self.state = 666
                self.oC_AnonymousPatternPart()
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_AnonymousPatternPartContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_AnonymousPatternPart" ):
                return visitor.visitOC_AnonymousPatternPart(self)
            else:
                return visitor.visitChildren(self)




    def oC_AnonymousPatternPart(self):

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

    class OC_PatternElementContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PatternElement" ):
                return visitor.visitOC_PatternElement(self)
            else:
                return visitor.visitChildren(self)




    def oC_PatternElement(self):

        localctx = CypherParser.OC_PatternElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_oC_PatternElement)
        self._la = 0 # Token type
        try:
            self.state = 685
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 671
                self.oC_NodePattern()
                self.state = 678
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,96,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 673
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 672
                            self.match(CypherParser.SP)


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

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 681
                self.match(CypherParser.T__5)
                self.state = 682
                self.oC_PatternElement()
                self.state = 683
                self.match(CypherParser.T__6)
                pass


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

    class OC_NodePatternContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_NodePattern" ):
                return visitor.visitOC_NodePattern(self)
            else:
                return visitor.visitChildren(self)




    def oC_NodePattern(self):

        localctx = CypherParser.OC_NodePatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_oC_NodePattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 687
            self.match(CypherParser.T__5)
            self.state = 689
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 688
                self.match(CypherParser.SP)


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




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




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




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

    class OC_PatternElementChainContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PatternElementChain" ):
                return visitor.visitOC_PatternElementChain(self)
            else:
                return visitor.visitChildren(self)




    def oC_PatternElementChain(self):

        localctx = CypherParser.OC_PatternElementChainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_oC_PatternElementChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 711
            self.oC_RelationshipPattern()
            self.state = 713
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 712
                self.match(CypherParser.SP)


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

    class OC_RelationshipPatternContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RelationshipPattern" ):
                return visitor.visitOC_RelationshipPattern(self)
            else:
                return visitor.visitChildren(self)




    def oC_RelationshipPattern(self):

        localctx = CypherParser.OC_RelationshipPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_oC_RelationshipPattern)
        self._la = 0 # Token type
        try:
            self.state = 781
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 717
                self.oC_LeftArrowHead()
                self.state = 719
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 718
                    self.match(CypherParser.SP)


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


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


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


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


                self.state = 735
                self.oC_RightArrowHead()
                pass

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


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


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


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


                self.state = 751
                self.oC_Dash()
                pass

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


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


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


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


                self.state = 767
                self.oC_RightArrowHead()
                pass

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


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


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


                self.state = 779
                self.oC_Dash()
                pass


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

    class OC_RelationshipDetailContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RelationshipDetail" ):
                return visitor.visitOC_RelationshipDetail(self)
            else:
                return visitor.visitChildren(self)




    def oC_RelationshipDetail(self):

        localctx = CypherParser.OC_RelationshipDetailContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_oC_RelationshipDetail)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            self.match(CypherParser.T__7)
            self.state = 785
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 784
                self.match(CypherParser.SP)


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




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




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


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




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

    class OC_PropertiesContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Properties" ):
                return visitor.visitOC_Properties(self)
            else:
                return visitor.visitChildren(self)




    def oC_Properties(self):

        localctx = CypherParser.OC_PropertiesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_oC_Properties)
        try:
            self.state = 812
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 810
                self.oC_MapLiteral()
                pass
            elif token in [CypherParser.T__25]:
                self.enterOuterAlt(localctx, 2)
                self.state = 811
                self.oC_Parameter()
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_RelationshipTypesContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RelationshipTypes" ):
                return visitor.visitOC_RelationshipTypes(self)
            else:
                return visitor.visitChildren(self)




    def oC_RelationshipTypes(self):

        localctx = CypherParser.OC_RelationshipTypesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_oC_RelationshipTypes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 814
            self.match(CypherParser.T__9)
            self.state = 816
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 815
                self.match(CypherParser.SP)


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


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


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


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

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

    class OC_NodeLabelsContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_NodeLabels" ):
                return visitor.visitOC_NodeLabels(self)
            else:
                return visitor.visitChildren(self)




    def oC_NodeLabels(self):

        localctx = CypherParser.OC_NodeLabelsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_oC_NodeLabels)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 835
            self.oC_NodeLabel()
            self.state = 842
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,138,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 837
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 836
                        self.match(CypherParser.SP)


                    self.state = 839
                    self.oC_NodeLabel() 
                self.state = 844
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,138,self._ctx)

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

    class OC_NodeLabelContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_NodeLabel" ):
                return visitor.visitOC_NodeLabel(self)
            else:
                return visitor.visitChildren(self)




    def oC_NodeLabel(self):

        localctx = CypherParser.OC_NodeLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_oC_NodeLabel)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 845
            self.match(CypherParser.T__9)
            self.state = 847
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 846
                self.match(CypherParser.SP)


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

    class OC_RangeLiteralContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RangeLiteral" ):
                return visitor.visitOC_RangeLiteral(self)
            else:
                return visitor.visitChildren(self)




    def oC_RangeLiteral(self):

        localctx = CypherParser.OC_RangeLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_oC_RangeLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 851
            self.match(CypherParser.T__4)
            self.state = 853
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 852
                self.match(CypherParser.SP)


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




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


                self.state = 869
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 97)) & ~0x3f) == 0 and ((1 << (_la - 97)) & ((1 << (CypherParser.HexInteger - 97)) | (1 << (CypherParser.DecimalInteger - 97)) | (1 << (CypherParser.OctalInteger - 97)))) != 0):
                    self.state = 865
                    self.oC_IntegerLiteral()
                    self.state = 867
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 866
                        self.match(CypherParser.SP)






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

    class OC_LabelNameContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_LabelName" ):
                return visitor.visitOC_LabelName(self)
            else:
                return visitor.visitChildren(self)




    def oC_LabelName(self):

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

    class OC_RelTypeNameContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RelTypeName" ):
                return visitor.visitOC_RelTypeName(self)
            else:
                return visitor.visitChildren(self)




    def oC_RelTypeName(self):

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

    class OC_ExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Expression" ):
                return visitor.visitOC_Expression(self)
            else:
                return visitor.visitChildren(self)




    def oC_Expression(self):

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

    class OC_OrExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_OrExpression" ):
                return visitor.visitOC_OrExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_OrExpression(self):

        localctx = CypherParser.OC_OrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_oC_OrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 879
            self.oC_XorExpression()
            self.state = 886
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,147,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 880
                    self.match(CypherParser.SP)
                    self.state = 881
                    self.match(CypherParser.OR)
                    self.state = 882
                    self.match(CypherParser.SP)
                    self.state = 883
                    self.oC_XorExpression() 
                self.state = 888
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,147,self._ctx)

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

    class OC_XorExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_XorExpression" ):
                return visitor.visitOC_XorExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_XorExpression(self):

        localctx = CypherParser.OC_XorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_oC_XorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 889
            self.oC_AndExpression()
            self.state = 896
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,148,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 890
                    self.match(CypherParser.SP)
                    self.state = 891
                    self.match(CypherParser.XOR)
                    self.state = 892
                    self.match(CypherParser.SP)
                    self.state = 893
                    self.oC_AndExpression() 
                self.state = 898
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,148,self._ctx)

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

    class OC_AndExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_AndExpression" ):
                return visitor.visitOC_AndExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_AndExpression(self):

        localctx = CypherParser.OC_AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_oC_AndExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 899
            self.oC_NotExpression()
            self.state = 906
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,149,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 900
                    self.match(CypherParser.SP)
                    self.state = 901
                    self.match(CypherParser.AND)
                    self.state = 902
                    self.match(CypherParser.SP)
                    self.state = 903
                    self.oC_NotExpression() 
                self.state = 908
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,149,self._ctx)

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

    class OC_NotExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_NotExpression" ):
                return visitor.visitOC_NotExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_NotExpression(self):

        localctx = CypherParser.OC_NotExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_oC_NotExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 915
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.NOT:
                self.state = 909
                self.match(CypherParser.NOT)
                self.state = 911
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 910
                    self.match(CypherParser.SP)


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

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

    class OC_ComparisonExpressionContext(ParserRuleContext):

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

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


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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_ComparisonExpression

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




    def oC_ComparisonExpression(self):

        localctx = CypherParser.OC_ComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_oC_ComparisonExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 920
            self.oC_AddOrSubtractExpression()
            self.state = 927
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 922
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 921
                        self.match(CypherParser.SP)


                    self.state = 924
                    self.oC_PartialComparisonExpression() 
                self.state = 929
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

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

    class OC_AddOrSubtractExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_AddOrSubtractExpression" ):
                return visitor.visitOC_AddOrSubtractExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_AddOrSubtractExpression(self):

        localctx = CypherParser.OC_AddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_oC_AddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 930
            self.oC_MultiplyDivideModuloExpression()
            self.state = 949
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,159,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 947
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
                    if la_ == 1:
                        self.state = 932
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 931
                            self.match(CypherParser.SP)


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


                        self.state = 938
                        self.oC_MultiplyDivideModuloExpression()
                        pass

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


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


                        self.state = 946
                        self.oC_MultiplyDivideModuloExpression()
                        pass

             
                self.state = 951
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,159,self._ctx)

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

    class OC_MultiplyDivideModuloExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_MultiplyDivideModuloExpression" ):
                return visitor.visitOC_MultiplyDivideModuloExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_MultiplyDivideModuloExpression(self):

        localctx = CypherParser.OC_MultiplyDivideModuloExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_oC_MultiplyDivideModuloExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 952
            self.oC_PowerOfExpression()
            self.state = 979
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,167,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 977
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
                    if la_ == 1:
                        self.state = 954
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 953
                            self.match(CypherParser.SP)


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


                        self.state = 960
                        self.oC_PowerOfExpression()
                        pass

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


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


                        self.state = 968
                        self.oC_PowerOfExpression()
                        pass

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


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


                        self.state = 976
                        self.oC_PowerOfExpression()
                        pass

             
                self.state = 981
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,167,self._ctx)

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

    class OC_PowerOfExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PowerOfExpression" ):
                return visitor.visitOC_PowerOfExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_PowerOfExpression(self):

        localctx = CypherParser.OC_PowerOfExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_oC_PowerOfExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 982
            self.oC_UnaryAddOrSubtractExpression()
            self.state = 993
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,170,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 984
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 983
                        self.match(CypherParser.SP)


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


                    self.state = 990
                    self.oC_UnaryAddOrSubtractExpression() 
                self.state = 995
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,170,self._ctx)

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

    class OC_UnaryAddOrSubtractExpressionContext(ParserRuleContext):

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

        def oC_StringListNullOperatorExpression(self):
            return self.getTypedRuleContext(CypherParser.OC_StringListNullOperatorExpressionContext,0)


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_UnaryAddOrSubtractExpression

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




    def oC_UnaryAddOrSubtractExpression(self):

        localctx = CypherParser.OC_UnaryAddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_oC_UnaryAddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CypherParser.T__12 or _la==CypherParser.T__13:
                self.state = 996
                _la = self._input.LA(1)
                if not(_la==CypherParser.T__12 or _la==CypherParser.T__13):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 998
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 997
                    self.match(CypherParser.SP)


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

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

    class OC_StringListNullOperatorExpressionContext(ParserRuleContext):

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

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


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


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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_StringListNullOperatorExpression

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




    def oC_StringListNullOperatorExpression(self):

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

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

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

             
                self.state = 1015
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,174,self._ctx)

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

    class OC_ListOperatorExpressionContext(ParserRuleContext):

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

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

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

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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_ListOperatorExpression

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




    def oC_ListOperatorExpression(self):

        localctx = CypherParser.OC_ListOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_oC_ListOperatorExpression)
        self._la = 0 # Token type
        try:
            self.state = 1041
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1016
                self.match(CypherParser.SP)
                self.state = 1017
                self.match(CypherParser.IN)
                self.state = 1019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1018
                    self.match(CypherParser.SP)


                self.state = 1021
                self.oC_PropertyOrLabelsExpression()
                pass

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


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

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


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


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


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


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

    class OC_StringOperatorExpressionContext(ParserRuleContext):

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_StringOperatorExpression

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




    def oC_StringOperatorExpression(self):

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

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

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


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


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

    class OC_NullOperatorExpressionContext(ParserRuleContext):

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

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

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

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

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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_NullOperatorExpression

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




    def oC_NullOperatorExpression(self):

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

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1064
                self.match(CypherParser.SP)
                self.state = 1065
                self.match(CypherParser.IS)
                self.state = 1066
                self.match(CypherParser.SP)
                self.state = 1067
                self.match(CypherParser.NOT)
                self.state = 1068
                self.match(CypherParser.SP)
                self.state = 1069
                self.match(CypherParser.NULL)
                pass


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

    class OC_PropertyOrLabelsExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PropertyOrLabelsExpression" ):
                return visitor.visitOC_PropertyOrLabelsExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_PropertyOrLabelsExpression(self):

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


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

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


                self.state = 1085
                self.oC_NodeLabels()


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

    class OC_AtomContext(ParserRuleContext):

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

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


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


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


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

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

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


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


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

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


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

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

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

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


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


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


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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Atom

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




    def oC_Atom(self):

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

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

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

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


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


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


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

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

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

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


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


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


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

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


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


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


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

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


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


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


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

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


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


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


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

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

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

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

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

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1166
                self.oC_Variable()
                pass


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

    class OC_LiteralContext(ParserRuleContext):

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

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


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

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


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

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


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


        def getRuleIndex(self):
            return CypherParser.RULE_oC_Literal

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




    def oC_Literal(self):

        localctx = CypherParser.OC_LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_oC_Literal)
        try:
            self.state = 1175
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.HexInteger, CypherParser.DecimalInteger, CypherParser.OctalInteger, CypherParser.ExponentDecimalReal, CypherParser.RegularDecimalReal]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1169
                self.oC_NumberLiteral()
                pass
            elif token in [CypherParser.StringLiteral]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1170
                self.match(CypherParser.StringLiteral)
                pass
            elif token in [CypherParser.TRUE, CypherParser.FALSE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1171
                self.oC_BooleanLiteral()
                pass
            elif token in [CypherParser.NULL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1172
                self.match(CypherParser.NULL)
                pass
            elif token in [CypherParser.T__22]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1173
                self.oC_MapLiteral()
                pass
            elif token in [CypherParser.T__7]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1174
                self.oC_ListLiteral()
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_BooleanLiteralContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_BooleanLiteral" ):
                return visitor.visitOC_BooleanLiteral(self)
            else:
                return visitor.visitChildren(self)




    def oC_BooleanLiteral(self):

        localctx = CypherParser.OC_BooleanLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_oC_BooleanLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1177
            _la = self._input.LA(1)
            if not(_la==CypherParser.TRUE or _la==CypherParser.FALSE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_ListLiteralContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ListLiteral" ):
                return visitor.visitOC_ListLiteral(self)
            else:
                return visitor.visitChildren(self)




    def oC_ListLiteral(self):

        localctx = CypherParser.OC_ListLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_oC_ListLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1179
            self.match(CypherParser.T__7)
            self.state = 1181
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1180
                self.match(CypherParser.SP)


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


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


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


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



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

    class OC_PartialComparisonExpressionContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CypherParser.RULE_oC_PartialComparisonExpression

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




    def oC_PartialComparisonExpression(self):

        localctx = CypherParser.OC_PartialComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_oC_PartialComparisonExpression)
        self._la = 0 # Token type
        try:
            self.state = 1234
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.T__2]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1204
                self.match(CypherParser.T__2)
                self.state = 1206
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1205
                    self.match(CypherParser.SP)


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


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


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


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


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


                self.state = 1233
                self.oC_AddOrSubtractExpression()
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_ParenthesizedExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ParenthesizedExpression" ):
                return visitor.visitOC_ParenthesizedExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_ParenthesizedExpression(self):

        localctx = CypherParser.OC_ParenthesizedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_oC_ParenthesizedExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1236
            self.match(CypherParser.T__5)
            self.state = 1238
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1237
                self.match(CypherParser.SP)


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


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

    class OC_RelationshipsPatternContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RelationshipsPattern" ):
                return visitor.visitOC_RelationshipsPattern(self)
            else:
                return visitor.visitChildren(self)




    def oC_RelationshipsPattern(self):

        localctx = CypherParser.OC_RelationshipsPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_oC_RelationshipsPattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1246
            self.oC_NodePattern()
            self.state = 1251 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1248
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1247
                        self.match(CypherParser.SP)


                    self.state = 1250
                    self.oC_PatternElementChain()

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

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

    class OC_FilterExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_FilterExpression" ):
                return visitor.visitOC_FilterExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_FilterExpression(self):

        localctx = CypherParser.OC_FilterExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_oC_FilterExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1255
            self.oC_IdInColl()
            self.state = 1260
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
            if la_ == 1:
                self.state = 1257
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CypherParser.SP:
                    self.state = 1256
                    self.match(CypherParser.SP)


                self.state = 1259
                self.oC_Where()


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

    class OC_IdInCollContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_IdInColl" ):
                return visitor.visitOC_IdInColl(self)
            else:
                return visitor.visitChildren(self)




    def oC_IdInColl(self):

        localctx = CypherParser.OC_IdInCollContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_oC_IdInColl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1262
            self.oC_Variable()
            self.state = 1263
            self.match(CypherParser.SP)
            self.state = 1264
            self.match(CypherParser.IN)
            self.state = 1265
            self.match(CypherParser.SP)
            self.state = 1266
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_FunctionInvocationContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_FunctionInvocation" ):
                return visitor.visitOC_FunctionInvocation(self)
            else:
                return visitor.visitChildren(self)




    def oC_FunctionInvocation(self):

        localctx = CypherParser.OC_FunctionInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_oC_FunctionInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1268
            self.oC_FunctionName()
            self.state = 1270
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1269
                self.match(CypherParser.SP)


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


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




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


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


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


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



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

    class OC_FunctionNameContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_FunctionName" ):
                return visitor.visitOC_FunctionName(self)
            else:
                return visitor.visitChildren(self)




    def oC_FunctionName(self):

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

    class OC_ExistentialSubqueryContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ExistentialSubquery" ):
                return visitor.visitOC_ExistentialSubquery(self)
            else:
                return visitor.visitChildren(self)




    def oC_ExistentialSubquery(self):

        localctx = CypherParser.OC_ExistentialSubqueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_oC_ExistentialSubquery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1306
            self.match(CypherParser.EXISTS)
            self.state = 1308
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1307
                self.match(CypherParser.SP)


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


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


                    self.state = 1319
                    self.oC_Where()


                pass
            else:
                raise NoViableAltException(self)

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


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

    class OC_ExplicitProcedureInvocationContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ExplicitProcedureInvocation" ):
                return visitor.visitOC_ExplicitProcedureInvocation(self)
            else:
                return visitor.visitChildren(self)




    def oC_ExplicitProcedureInvocation(self):

        localctx = CypherParser.OC_ExplicitProcedureInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_oC_ExplicitProcedureInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1329
            self.oC_ProcedureName()
            self.state = 1331
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1330
                self.match(CypherParser.SP)


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


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


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


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


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



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

    class OC_ImplicitProcedureInvocationContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ImplicitProcedureInvocation" ):
                return visitor.visitOC_ImplicitProcedureInvocation(self)
            else:
                return visitor.visitChildren(self)




    def oC_ImplicitProcedureInvocation(self):

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

    class OC_ProcedureResultFieldContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ProcedureResultField" ):
                return visitor.visitOC_ProcedureResultField(self)
            else:
                return visitor.visitChildren(self)




    def oC_ProcedureResultField(self):

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

    class OC_ProcedureNameContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ProcedureName" ):
                return visitor.visitOC_ProcedureName(self)
            else:
                return visitor.visitChildren(self)




    def oC_ProcedureName(self):

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

    class OC_NamespaceContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Namespace" ):
                return visitor.visitOC_Namespace(self)
            else:
                return visitor.visitChildren(self)




    def oC_Namespace(self):

        localctx = CypherParser.OC_NamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_oC_Namespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1370
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,246,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1365
                    self.oC_SymbolicName()
                    self.state = 1366
                    self.match(CypherParser.T__24) 
                self.state = 1372
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,246,self._ctx)

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

    class OC_ListComprehensionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ListComprehension" ):
                return visitor.visitOC_ListComprehension(self)
            else:
                return visitor.visitChildren(self)




    def oC_ListComprehension(self):

        localctx = CypherParser.OC_ListComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_oC_ListComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1373
            self.match(CypherParser.T__7)
            self.state = 1375
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1374
                self.match(CypherParser.SP)


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


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


                self.state = 1385
                self.oC_Expression()


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


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

    class OC_PatternComprehensionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PatternComprehension" ):
                return visitor.visitOC_PatternComprehension(self)
            else:
                return visitor.visitChildren(self)




    def oC_PatternComprehension(self):

        localctx = CypherParser.OC_PatternComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_oC_PatternComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1393
            self.match(CypherParser.T__7)
            self.state = 1395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1394
                self.match(CypherParser.SP)


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


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




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


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




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


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


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

    class OC_PropertyLookupContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PropertyLookup" ):
                return visitor.visitOC_PropertyLookup(self)
            else:
                return visitor.visitChildren(self)




    def oC_PropertyLookup(self):

        localctx = CypherParser.OC_PropertyLookupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_oC_PropertyLookup)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1427
            self.match(CypherParser.T__24)
            self.state = 1429
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1428
                self.match(CypherParser.SP)


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

    class OC_CaseExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_CaseExpression" ):
                return visitor.visitOC_CaseExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_CaseExpression(self):

        localctx = CypherParser.OC_CaseExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_oC_CaseExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,267,self._ctx)
            if la_ == 1:
                self.state = 1433
                self.match(CypherParser.CASE)
                self.state = 1438 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1435
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CypherParser.SP:
                            self.state = 1434
                            self.match(CypherParser.SP)


                        self.state = 1437
                        self.oC_CaseAlternative()

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

                pass

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


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


                        self.state = 1450
                        self.oC_CaseAlternative()

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

                pass


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


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


                self.state = 1464
                self.oC_Expression()


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


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

    class OC_CaseAlternativeContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_CaseAlternative" ):
                return visitor.visitOC_CaseAlternative(self)
            else:
                return visitor.visitChildren(self)




    def oC_CaseAlternative(self):

        localctx = CypherParser.OC_CaseAlternativeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_oC_CaseAlternative)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1472
            self.match(CypherParser.WHEN)
            self.state = 1474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1473
                self.match(CypherParser.SP)


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


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


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

    class OC_VariableContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Variable" ):
                return visitor.visitOC_Variable(self)
            else:
                return visitor.visitChildren(self)




    def oC_Variable(self):

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

    class OC_NumberLiteralContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_NumberLiteral" ):
                return visitor.visitOC_NumberLiteral(self)
            else:
                return visitor.visitChildren(self)




    def oC_NumberLiteral(self):

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

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

    class OC_MapLiteralContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_MapLiteral" ):
                return visitor.visitOC_MapLiteral(self)
            else:
                return visitor.visitChildren(self)




    def oC_MapLiteral(self):

        localctx = CypherParser.OC_MapLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_oC_MapLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1492
            self.match(CypherParser.T__22)
            self.state = 1494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CypherParser.SP:
                self.state = 1493
                self.match(CypherParser.SP)


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


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


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


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


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


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


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


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



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

    class OC_ParameterContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Parameter" ):
                return visitor.visitOC_Parameter(self)
            else:
                return visitor.visitChildren(self)




    def oC_Parameter(self):

        localctx = CypherParser.OC_ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_oC_Parameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1533
            self.match(CypherParser.T__25)
            self.state = 1536
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.state = 1534
                self.oC_SymbolicName()
                pass
            elif token in [CypherParser.DecimalInteger]:
                self.state = 1535
                self.match(CypherParser.DecimalInteger)
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_PropertyExpressionContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PropertyExpression" ):
                return visitor.visitOC_PropertyExpression(self)
            else:
                return visitor.visitChildren(self)




    def oC_PropertyExpression(self):

        localctx = CypherParser.OC_PropertyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_oC_PropertyExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1538
            self.oC_Atom()
            self.state = 1543 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1540
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CypherParser.SP:
                        self.state = 1539
                        self.match(CypherParser.SP)


                    self.state = 1542
                    self.oC_PropertyLookup()

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

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

    class OC_PropertyKeyNameContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_PropertyKeyName" ):
                return visitor.visitOC_PropertyKeyName(self)
            else:
                return visitor.visitChildren(self)




    def oC_PropertyKeyName(self):

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

    class OC_IntegerLiteralContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_IntegerLiteral" ):
                return visitor.visitOC_IntegerLiteral(self)
            else:
                return visitor.visitChildren(self)




    def oC_IntegerLiteral(self):

        localctx = CypherParser.OC_IntegerLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_oC_IntegerLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1549
            _la = self._input.LA(1)
            if not(((((_la - 97)) & ~0x3f) == 0 and ((1 << (_la - 97)) & ((1 << (CypherParser.HexInteger - 97)) | (1 << (CypherParser.DecimalInteger - 97)) | (1 << (CypherParser.OctalInteger - 97)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_DoubleLiteralContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_DoubleLiteral" ):
                return visitor.visitOC_DoubleLiteral(self)
            else:
                return visitor.visitChildren(self)




    def oC_DoubleLiteral(self):

        localctx = CypherParser.OC_DoubleLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_oC_DoubleLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1551
            _la = self._input.LA(1)
            if not(_la==CypherParser.ExponentDecimalReal or _la==CypherParser.RegularDecimalReal):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_SchemaNameContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_SchemaName" ):
                return visitor.visitOC_SchemaName(self)
            else:
                return visitor.visitChildren(self)




    def oC_SchemaName(self):

        localctx = CypherParser.OC_SchemaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_oC_SchemaName)
        try:
            self.state = 1555
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CypherParser.COUNT, CypherParser.ANY, CypherParser.NONE, CypherParser.SINGLE, CypherParser.HexLetter, CypherParser.FILTER, CypherParser.EXTRACT, CypherParser.UnescapedSymbolicName, CypherParser.EscapedSymbolicName]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1553
                self.oC_SymbolicName()
                pass
            elif token in [CypherParser.UNION, CypherParser.ALL, CypherParser.OPTIONAL, CypherParser.MATCH, CypherParser.UNWIND, CypherParser.AS, CypherParser.MERGE, CypherParser.ON, CypherParser.CREATE, CypherParser.SET, CypherParser.DETACH, CypherParser.DELETE, CypherParser.REMOVE, CypherParser.WITH, CypherParser.RETURN, CypherParser.DISTINCT, CypherParser.ORDER, CypherParser.BY, CypherParser.L_SKIP, CypherParser.LIMIT, CypherParser.ASCENDING, CypherParser.ASC, CypherParser.DESCENDING, CypherParser.DESC, CypherParser.WHERE, CypherParser.OR, CypherParser.XOR, CypherParser.AND, CypherParser.NOT, CypherParser.IN, CypherParser.STARTS, CypherParser.ENDS, CypherParser.CONTAINS, CypherParser.IS, CypherParser.NULL, CypherParser.TRUE, CypherParser.FALSE, CypherParser.EXISTS, CypherParser.CASE, CypherParser.ELSE, CypherParser.END, CypherParser.WHEN, CypherParser.THEN, CypherParser.CONSTRAINT, CypherParser.DO, CypherParser.FOR, CypherParser.REQUIRE, CypherParser.UNIQUE, CypherParser.MANDATORY, CypherParser.SCALAR, CypherParser.OF, CypherParser.ADD, CypherParser.DROP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1554
                self.oC_ReservedWord()
                pass
            else:
                raise NoViableAltException(self)

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

    class OC_ReservedWordContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_ReservedWord" ):
                return visitor.visitOC_ReservedWord(self)
            else:
                return visitor.visitChildren(self)




    def oC_ReservedWord(self):

        localctx = CypherParser.OC_ReservedWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_oC_ReservedWord)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1557
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.UNION) | (1 << CypherParser.ALL) | (1 << CypherParser.OPTIONAL) | (1 << CypherParser.MATCH) | (1 << CypherParser.UNWIND) | (1 << CypherParser.AS) | (1 << CypherParser.MERGE) | (1 << CypherParser.ON) | (1 << CypherParser.CREATE) | (1 << CypherParser.SET) | (1 << CypherParser.DETACH) | (1 << CypherParser.DELETE) | (1 << CypherParser.REMOVE) | (1 << CypherParser.WITH) | (1 << CypherParser.RETURN) | (1 << CypherParser.DISTINCT))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CypherParser.ORDER - 64)) | (1 << (CypherParser.BY - 64)) | (1 << (CypherParser.L_SKIP - 64)) | (1 << (CypherParser.LIMIT - 64)) | (1 << (CypherParser.ASCENDING - 64)) | (1 << (CypherParser.ASC - 64)) | (1 << (CypherParser.DESCENDING - 64)) | (1 << (CypherParser.DESC - 64)) | (1 << (CypherParser.WHERE - 64)) | (1 << (CypherParser.OR - 64)) | (1 << (CypherParser.XOR - 64)) | (1 << (CypherParser.AND - 64)) | (1 << (CypherParser.NOT - 64)) | (1 << (CypherParser.IN - 64)) | (1 << (CypherParser.STARTS - 64)) | (1 << (CypherParser.ENDS - 64)) | (1 << (CypherParser.CONTAINS - 64)) | (1 << (CypherParser.IS - 64)) | (1 << (CypherParser.NULL - 64)) | (1 << (CypherParser.TRUE - 64)) | (1 << (CypherParser.FALSE - 64)) | (1 << (CypherParser.EXISTS - 64)) | (1 << (CypherParser.CASE - 64)) | (1 << (CypherParser.ELSE - 64)) | (1 << (CypherParser.END - 64)) | (1 << (CypherParser.WHEN - 64)) | (1 << (CypherParser.THEN - 64)) | (1 << (CypherParser.CONSTRAINT - 64)) | (1 << (CypherParser.DO - 64)) | (1 << (CypherParser.FOR - 64)) | (1 << (CypherParser.REQUIRE - 64)) | (1 << (CypherParser.UNIQUE - 64)) | (1 << (CypherParser.MANDATORY - 64)) | (1 << (CypherParser.SCALAR - 64)) | (1 << (CypherParser.OF - 64)) | (1 << (CypherParser.ADD - 64)) | (1 << (CypherParser.DROP - 64)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_SymbolicNameContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_SymbolicName" ):
                return visitor.visitOC_SymbolicName(self)
            else:
                return visitor.visitChildren(self)




    def oC_SymbolicName(self):

        localctx = CypherParser.OC_SymbolicNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_oC_SymbolicName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1559
            _la = self._input.LA(1)
            if not(((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (CypherParser.COUNT - 83)) | (1 << (CypherParser.ANY - 83)) | (1 << (CypherParser.NONE - 83)) | (1 << (CypherParser.SINGLE - 83)) | (1 << (CypherParser.HexLetter - 83)) | (1 << (CypherParser.FILTER - 83)) | (1 << (CypherParser.EXTRACT - 83)) | (1 << (CypherParser.UnescapedSymbolicName - 83)) | (1 << (CypherParser.EscapedSymbolicName - 83)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_LeftArrowHeadContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_LeftArrowHead" ):
                return visitor.visitOC_LeftArrowHead(self)
            else:
                return visitor.visitChildren(self)




    def oC_LeftArrowHead(self):

        localctx = CypherParser.OC_LeftArrowHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_oC_LeftArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1561
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__18) | (1 << CypherParser.T__26) | (1 << CypherParser.T__27) | (1 << CypherParser.T__28) | (1 << CypherParser.T__29))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_RightArrowHeadContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_RightArrowHead" ):
                return visitor.visitOC_RightArrowHead(self)
            else:
                return visitor.visitChildren(self)




    def oC_RightArrowHead(self):

        localctx = CypherParser.OC_RightArrowHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_oC_RightArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1563
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__19) | (1 << CypherParser.T__30) | (1 << CypherParser.T__31) | (1 << CypherParser.T__32) | (1 << CypherParser.T__33))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OC_DashContext(ParserRuleContext):

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOC_Dash" ):
                return visitor.visitOC_Dash(self)
            else:
                return visitor.visitChildren(self)




    def oC_Dash(self):

        localctx = CypherParser.OC_DashContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_oC_Dash)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1565
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CypherParser.T__13) | (1 << CypherParser.T__34) | (1 << CypherParser.T__35) | (1 << CypherParser.T__36) | (1 << CypherParser.T__37) | (1 << CypherParser.T__38) | (1 << CypherParser.T__39) | (1 << CypherParser.T__40) | (1 << CypherParser.T__41) | (1 << CypherParser.T__42) | (1 << CypherParser.T__43) | (1 << CypherParser.T__44))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





