From 2017bc5808b33867d4951bff1c2a1e547bf93c50 Mon Sep 17 00:00:00 2001
From: Emil Andersson <HerrEmil@users.noreply.github.com>
Date: Fri, 14 Aug 2020 13:26:18 +0200
Subject: [PATCH 01/23] add edit frame and initial monaco implementation

---
 build_scripts/webpack-plugins.js              |  4 +-
 package.json                                  |  2 +
 src/browser/modules/Editor/Monaco.tsx         | 50 +++++++++++++++++++
 src/browser/modules/Stream/EditFrame.tsx      | 31 ++++++++++++
 src/browser/modules/Stream/Stream.jsx         |  2 +
 .../services/commandInterpreterHelper.js      |  7 +++
 yarn.lock                                     | 12 +++++
 7 files changed, 107 insertions(+), 1 deletion(-)
 create mode 100644 src/browser/modules/Editor/Monaco.tsx
 create mode 100644 src/browser/modules/Stream/EditFrame.tsx

diff --git a/build_scripts/webpack-plugins.js b/build_scripts/webpack-plugins.js
index d0b7c67c72e..bb5dc0681c3 100644
--- a/build_scripts/webpack-plugins.js
+++ b/build_scripts/webpack-plugins.js
@@ -29,6 +29,7 @@ const BundleAnalyzerPlugin = require('webpack-bundle-analyzer')
   .BundleAnalyzerPlugin
 const ForkTsCheckerNotifierWebpackPlugin = require('fork-ts-checker-notifier-webpack-plugin')
 const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin')
+const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin')
 const manifestGeneration = require('./generate-manifest-helpers')
 const ReactRefreshWebpackPlugin = require('@pmmmwh/react-refresh-webpack-plugin')
 
@@ -91,7 +92,8 @@ module.exports = () => {
     new ForkTsCheckerNotifierWebpackPlugin({
       title: 'TypeScript',
       excludeWarnings: false
-    })
+    }),
+    new MonacoWebpackPlugin()
   ]
 
   if (!helpers.isProduction) {
diff --git a/package.json b/package.json
index 81e6a8ed840..bd0d37b6918 100644
--- a/package.json
+++ b/package.json
@@ -115,6 +115,7 @@
     "lint-staged": "^4.1.3",
     "mini-css-extract-plugin": "^0.4.4",
     "mockdate": "^2.0.5",
+    "monaco-editor-webpack-plugin": "^1.9.0",
     "ncp": "^2.0.0",
     "nock": "^12.0.3",
     "postcss": "^6.0.11",
@@ -166,6 +167,7 @@
     "jsonic": "^0.3.0",
     "jszip": "^3.2.2",
     "lodash-es": "^4.17.15",
+    "monaco-editor": "^0.20.0",
     "neo4j-driver": "^4.1.0",
     "prop-types": "^15.7.2",
     "react": "^16.9.0",
diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
new file mode 100644
index 00000000000..9baddce899d
--- /dev/null
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import * as monaco from 'monaco-editor'
+import React, { useEffect, useState, useRef } from 'react'
+
+const Monaco: React.FC = () => {
+  const editorRef = (useRef(null) as unknown) as React.MutableRefObject<
+    monaco.editor.IStandaloneCodeEditor
+  >
+  const [text, setText] = useState('')
+  console.log(text)
+
+  useEffect(() => {
+    editorRef.current = monaco.editor.create(
+      document.getElementById('mon-editor') as HTMLElement
+    )
+
+    editorRef.current.onDidChangeModelContent(() => {
+      setText(editorRef.current.getValue())
+      console.log(editorRef.current.getValue())
+    })
+
+    // todo dispose of editor
+  }, [])
+  return (
+    <>
+      <div id="mon-editor" style={{ height: '700px', width: '500px' }} />
+    </>
+  )
+}
+
+export default Monaco
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
new file mode 100644
index 00000000000..205d9bffffc
--- /dev/null
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import React from 'react'
+import Monaco from '../Editor/Monaco'
+import FrameTemplate from '../Frame/FrameTemplate'
+
+const EditFrame = (props: { query: string }): JSX.Element => {
+  const { query } = props
+  console.log(query)
+  return <FrameTemplate header={'query'} contents={<Monaco></Monaco>} />
+}
+
+export default EditFrame
diff --git a/src/browser/modules/Stream/Stream.jsx b/src/browser/modules/Stream/Stream.jsx
index 922810f70c4..6da761798a1 100644
--- a/src/browser/modules/Stream/Stream.jsx
+++ b/src/browser/modules/Stream/Stream.jsx
@@ -48,6 +48,7 @@ import { getActiveConnectionData } from 'shared/modules/connections/connectionsD
 import { getScrollToTop } from 'shared/modules/settings/settingsDuck'
 import DbsFrame from './Auth/DbsFrame'
 import { getLatestFromFrameStack } from './stream.utils'
+import EditFrame from './EditFrame'
 
 const getFrame = type => {
   const trans = {
@@ -76,6 +77,7 @@ const getFrame = type => {
     'reset-db': UseDbFrame,
     dbs: DbsFrame,
     style: StyleFrame,
+    'test-edit': EditFrame,
     default: Frame
   }
   return trans[type] || trans.default
diff --git a/src/shared/services/commandInterpreterHelper.js b/src/shared/services/commandInterpreterHelper.js
index 1f32bfbfe57..7890bc337e4 100644
--- a/src/shared/services/commandInterpreterHelper.js
+++ b/src/shared/services/commandInterpreterHelper.js
@@ -788,6 +788,13 @@ ${param}`)
       }
     }
   },
+  {
+    name: 'test-edit',
+    match: cmd => cmd === 'test-edit',
+    exec: (action, cmdchar, put, store) => {
+      put(frames.add({ type: 'test-edit' }))
+    }
+  },
   {
     name: 'catch-all',
     match: () => true,
diff --git a/yarn.lock b/yarn.lock
index b5321ccf7d0..8f864343388 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -8986,6 +8986,18 @@ moment@^2.27.0:
   resolved "https://neo.jfrog.io/neo/api/npm/npm/moment/-/moment-2.28.0.tgz#cdfe73ce01327cee6537b0fafac2e0f21a237d75"
   integrity sha1-zf5zzgEyfO5lN7D6+sLg8hojfXU=
 
+monaco-editor-webpack-plugin@^1.9.0:
+  version "1.9.0"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/monaco-editor-webpack-plugin/-/monaco-editor-webpack-plugin-1.9.0.tgz#5b547281b9f404057dc5d8c5722390df9ac90be6"
+  integrity sha1-W1Rygbn0BAV9xdjFciOQ35rJC+Y=
+  dependencies:
+    loader-utils "^1.2.3"
+
+monaco-editor@^0.20.0:
+  version "0.20.0"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/monaco-editor/-/monaco-editor-0.20.0.tgz#5d5009343a550124426cb4d965a4d27a348b4dea"
+  integrity sha1-XVAJNDpVASRCbLTZZaTSejSLTeo=
+
 moo@^0.4.3:
   version "0.4.3"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/moo/-/moo-0.4.3.tgz#3f847a26f31cf625a956a87f2b10fbc013bfd10e"

From ba075106e7c8b80bb8a4720b44ac33ea176fb917 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Wed, 9 Sep 2020 13:01:43 +0200
Subject: [PATCH 02/23] add edit browser command

---
 src/browser/modules/Stream/Stream.jsx         |  2 +-
 .../services/commandInterpreterHelper.js      | 14 ++++++++++----
 .../services/commandInterpreterHelper.test.js | 19 +++++++++++++++++++
 3 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/src/browser/modules/Stream/Stream.jsx b/src/browser/modules/Stream/Stream.jsx
index 6da761798a1..86e890c3908 100644
--- a/src/browser/modules/Stream/Stream.jsx
+++ b/src/browser/modules/Stream/Stream.jsx
@@ -77,7 +77,7 @@ const getFrame = type => {
     'reset-db': UseDbFrame,
     dbs: DbsFrame,
     style: StyleFrame,
-    'test-edit': EditFrame,
+    edit: EditFrame,
     default: Frame
   }
   return trans[type] || trans.default
diff --git a/src/shared/services/commandInterpreterHelper.js b/src/shared/services/commandInterpreterHelper.js
index 7890bc337e4..cb1c6eddd00 100644
--- a/src/shared/services/commandInterpreterHelper.js
+++ b/src/shared/services/commandInterpreterHelper.js
@@ -789,10 +789,16 @@ ${param}`)
     }
   },
   {
-    name: 'test-edit',
-    match: cmd => cmd === 'test-edit',
-    exec: (action, cmdchar, put, store) => {
-      put(frames.add({ type: 'test-edit' }))
+    name: 'edit',
+    match: cmd => cmd.startsWith('edit'),
+    exec: (action, cmdchar, put) => {
+      put(
+        frames.add({
+          ...action,
+          query: action.cmd.split(`${cmdchar}edit`)[1].trim(),
+          type: 'edit'
+        })
+      )
     }
   },
   {
diff --git a/src/shared/services/commandInterpreterHelper.test.js b/src/shared/services/commandInterpreterHelper.test.js
index 7dc2bf97d04..42b48310a14 100644
--- a/src/shared/services/commandInterpreterHelper.test.js
+++ b/src/shared/services/commandInterpreterHelper.test.js
@@ -34,6 +34,25 @@ describe('commandInterpreterHelper', () => {
       expect(actualCommandName).toEqual(expectedCommandName)
     })
 
+    it('should recognize :edit command with query', () => {
+      const query = 'some cypher query'
+      const cmd = `edit ${query}`
+      const expectedCommandName = 'edit'
+
+      const actualCommandName = helper.interpret(cmd).name
+
+      expect(actualCommandName).toEqual(expectedCommandName)
+    })
+
+    it('should recognize :edit command without query', () => {
+      const cmd = 'edit'
+      const expectedCommandName = 'edit'
+
+      const actualCommandName = helper.interpret(cmd).name
+
+      expect(actualCommandName).toEqual(expectedCommandName)
+    })
+
     test('should find :config helper with params', () => {
       // Given
       const cmd = 'config cmdchar:"/"'

From 498de4b9630ce263190efadbc29b6ed9b6225a0a Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Wed, 9 Sep 2020 14:37:25 +0200
Subject: [PATCH 03/23] fix monaco loading in jest setup

---
 jest.config.js           | 8 +++++---
 test_utils/setupTests.js | 2 ++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/jest.config.js b/jest.config.js
index df57b9d5fce..436458ac059 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -15,17 +15,19 @@ module.exports = {
     '/node_modules/'
   ],
   transformIgnorePatterns: [
-    '/node_modules/(?!lodash-es|@neo4j/browser-lambda-parser|react-dnd|dnd-core)'
+    '/node_modules/(?!lodash-es|@neo4j/browser-lambda-parser|react-dnd|dnd-core|monaco-editor)'
   ],
   moduleNameMapper: {
-    '\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga|html)$':
+    '\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga|html|css)$':
       '<rootDir>/test_utils/__mocks__/fileMock.js',
     '\\.(css|less)$': '<rootDir>/test_utils/__mocks__/styleMock.js',
     '^browser-styles(.*)$': '<rootDir>/src/browser/styles$1',
     '^browser-components(.*)$': '<rootDir>/src/browser/components$1',
     '^browser-hooks(.*)$': '<rootDir>/src/browser/hooks$1',
     'worker-loader': '<rootDir>/test_utils/__mocks__/workerLoaderMock.js',
-    'project-root(.*)$': '<rootDir>$1'
+    'project-root(.*)$': '<rootDir>$1',
+    '^monaco-editor$':
+      '<rootDir>/node_modules/monaco-editor/esm/vs/editor/editor.main.js'
   },
   modulePaths: ['<rootDir>/src', '<rootDir>/src/shared'],
   collectCoverageFrom: [
diff --git a/test_utils/setupTests.js b/test_utils/setupTests.js
index ccffdcf00ef..45bd06afad4 100644
--- a/test_utils/setupTests.js
+++ b/test_utils/setupTests.js
@@ -28,3 +28,5 @@ global.document.createRange = () => {
     getClientRects: () => []
   }
 }
+// needed for jest to import monaco
+document.queryCommandSupported = () => false

From df3e4d716f44b013b5acb3b98fe700a20d29aac6 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Mon, 14 Sep 2020 11:17:54 +0200
Subject: [PATCH 04/23] invalidate connection when driver is null

---
 src/shared/services/bolt/boltConnection.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/shared/services/bolt/boltConnection.js b/src/shared/services/bolt/boltConnection.js
index 26b9cd1ba17..933fc0ca1dc 100644
--- a/src/shared/services/bolt/boltConnection.js
+++ b/src/shared/services/bolt/boltConnection.js
@@ -46,6 +46,11 @@ export const hasMultiDbSupport = async () => {
 }
 
 const validateConnection = (driver, res, rej) => {
+  if (driver === null) {
+    rej()
+    return
+  }
+
   driver
     .supportsMultiDb()
     .then(multiDbSupport => {

From 59f41a1326cd05a8cacbf3cdde88ea66db590e75 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Fri, 11 Sep 2020 16:28:33 +0200
Subject: [PATCH 05/23] add edit frame run button and dispose monaco om
 component destroy

---
 src/browser/modules/Editor/Monaco.tsx       | 72 +++++++++++++--------
 src/browser/modules/Frame/FrameTemplate.jsx |  1 +
 src/browser/modules/Frame/FrameTitlebar.jsx | 37 +++++++----
 src/browser/modules/Stream/EditFrame.tsx    | 39 +++++++++--
 src/shared/modules/stream/streamDuck.ts     |  2 +-
 5 files changed, 105 insertions(+), 46 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index 9baddce899d..a9539f8f0cc 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -19,32 +19,52 @@
  */
 
 import * as monaco from 'monaco-editor'
-import React, { useEffect, useState, useRef } from 'react'
-
-const Monaco: React.FC = () => {
-  const editorRef = (useRef(null) as unknown) as React.MutableRefObject<
-    monaco.editor.IStandaloneCodeEditor
-  >
-  const [text, setText] = useState('')
-  console.log(text)
-
-  useEffect(() => {
-    editorRef.current = monaco.editor.create(
-      document.getElementById('mon-editor') as HTMLElement
-    )
-
-    editorRef.current.onDidChangeModelContent(() => {
-      setText(editorRef.current.getValue())
-      console.log(editorRef.current.getValue())
-    })
-
-    // todo dispose of editor
-  }, [])
-  return (
-    <>
-      <div id="mon-editor" style={{ height: '700px', width: '500px' }} />
-    </>
-  )
+import React, {
+  forwardRef,
+  useEffect,
+  useImperativeHandle,
+  useRef
+} from 'react'
+
+export interface monacoHandles {
+  getValue: () => string
+  setValue: (value: string) => void
+  dispose: () => void
 }
 
+const Monaco = forwardRef<monacoHandles, any>(
+  (_props, ref): JSX.Element => {
+    const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
+
+    useEffect(() => {
+      editorRef.current = monaco.editor.create(
+        document.getElementById('mon-editor') as HTMLElement,
+        { automaticLayout: true }
+      )
+
+      editorRef.current.onDidChangeModelContent(() => {
+        console.log(editorRef.current?.getValue())
+      })
+
+      return () => {
+        editorRef.current?.dispose()
+      }
+    }, [])
+
+    useImperativeHandle(ref, () => ({
+      getValue() {
+        return editorRef.current?.getValue() || ''
+      },
+      setValue(value) {
+        editorRef.current?.setValue(value)
+      },
+      dispose() {
+        editorRef.current?.dispose()
+      }
+    }))
+
+    return <div id="mon-editor" style={{ height: 'auto', width: '100%' }} />
+  }
+)
+
 export default Monaco
diff --git a/src/browser/modules/Frame/FrameTemplate.jsx b/src/browser/modules/Frame/FrameTemplate.jsx
index bb3670608f2..9e55d287306 100644
--- a/src/browser/modules/Frame/FrameTemplate.jsx
+++ b/src/browser/modules/Frame/FrameTemplate.jsx
@@ -127,6 +127,7 @@ class FrameTemplate extends Component {
             numRecords={this.props.numRecords || 0}
             getRecords={this.props.getRecords}
             visElement={this.props.visElement}
+            runQuery={this.props.runQuery}
           />
         )}
         <StyledFrameBody
diff --git a/src/browser/modules/Frame/FrameTitlebar.jsx b/src/browser/modules/Frame/FrameTitlebar.jsx
index a23a604beca..3e3ef6aad77 100644
--- a/src/browser/modules/Frame/FrameTitlebar.jsx
+++ b/src/browser/modules/Frame/FrameTitlebar.jsx
@@ -23,6 +23,8 @@ import React, { Component } from 'react'
 import { withBus } from 'react-suber'
 import { saveAs } from 'file-saver'
 import { map } from 'lodash-es'
+import SVGInline from 'react-svg-inline'
+import controlsPlay from 'icons/controls-play.svg'
 
 import * as editor from 'shared/modules/editor/editorDuck'
 import * as commands from 'shared/modules/commands/commandsDuck'
@@ -37,14 +39,15 @@ import { FrameButton } from 'browser-components/buttons'
 import Render from 'browser-components/Render'
 import { CSVSerializer } from 'services/serializer'
 import {
-  ExpandIcon,
-  ContractIcon,
-  RefreshIcon,
   CloseIcon,
-  UpIcon,
+  ContractIcon,
   DownIcon,
+  DownloadIcon,
+  ExpandIcon,
   PinIcon,
-  DownloadIcon
+  PlainPlayIcon,
+  RefreshIcon,
+  UpIcon
 } from 'browser-components/icons/Icons'
 import {
   DottedLineHover,
@@ -244,13 +247,20 @@ class FrameTitlebar extends Component {
           >
             {expandCollapseIcon}
           </FrameButton>
-          <FrameButton
-            data-testid="rerunFrameButton"
-            title="Rerun"
-            onClick={() => props.onReRunClick(frame)}
-          >
-            <RefreshIcon />
-          </FrameButton>
+          <Render if={frame.type === 'edit'}>
+            <FrameButton title="Run" onClick={() => props.onRunClick()}>
+              <SVGInline svg={controlsPlay} width="12px" />
+            </FrameButton>
+          </Render>
+          <Render if={frame.type !== 'edit'}>
+            <FrameButton
+              data-testid="rerunFrameButton"
+              title="Rerun"
+              onClick={() => props.onReRunClick(frame)}
+            >
+              <RefreshIcon />
+            </FrameButton>
+          </Render>
           <FrameButton
             title="Close"
             onClick={() =>
@@ -287,6 +297,9 @@ const mapDispatchToProps = (dispatch, ownProps) => {
       }
       dispatch(remove(id))
     },
+    onRunClick: () => {
+      ownProps.runQuery()
+    },
     onReRunClick: ({ cmd, useDb, id, requestId }) => {
       if (requestId) {
         dispatch(cancelRequest(requestId))
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index 205d9bffffc..11e8b706cde 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -18,14 +18,39 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import React from 'react'
-import Monaco from '../Editor/Monaco'
+import React, { Dispatch, useRef } from 'react'
+import { connect } from 'react-redux'
+import { Action } from 'redux'
+import Monaco, { monacoHandles } from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
+import { executeCommand } from 'shared/modules/commands/commandsDuck'
+import { Frame } from 'shared/modules/stream/streamDuck'
 
-const EditFrame = (props: { query: string }): JSX.Element => {
-  const { query } = props
-  console.log(query)
-  return <FrameTemplate header={'query'} contents={<Monaco></Monaco>} />
+interface EditFrameProps {
+  frame: Frame
+  runQuery: (query: string) => void
 }
 
-export default EditFrame
+const EditFrame = ({ frame, runQuery }: EditFrameProps): JSX.Element => {
+  const monaco = useRef<monacoHandles>(null)
+
+  return (
+    <FrameTemplate
+      contents={<Monaco ref={monaco}></Monaco>}
+      header={frame}
+      runQuery={() => {
+        const value = monaco.current?.getValue() || ''
+        runQuery(value)
+      }}
+    />
+  )
+}
+
+const mapDispatchToProps = (dispatch: Dispatch<Action>) => ({
+  runQuery: (query: string) => {
+    dispatch(executeCommand(query))
+    // todo update query and cmd in store.frames?
+  }
+})
+
+export default connect(null, mapDispatchToProps)(EditFrame)
diff --git a/src/shared/modules/stream/streamDuck.ts b/src/shared/modules/stream/streamDuck.ts
index 11c14b9658d..18302a7b69d 100644
--- a/src/shared/modules/stream/streamDuck.ts
+++ b/src/shared/modules/stream/streamDuck.ts
@@ -209,7 +209,7 @@ interface FrameError {
 }
 
 // When more code is typed, frame should be a union type of different frames
-interface Frame {
+export interface Frame {
   autoCommit: boolean
   cmd: string
   connectionData: ConnectionData

From 0beca40fcc8be4a724bb27e4d01fb535e59c90d0 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Wed, 16 Sep 2020 13:37:07 +0200
Subject: [PATCH 06/23] set monaco editor initial value and unique id

---
 src/browser/modules/Editor/Monaco.tsx    | 23 ++++++++++-------------
 src/browser/modules/Stream/EditFrame.tsx | 12 ++++++++----
 2 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index a9539f8f0cc..bde47e9ee8b 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -26,26 +26,26 @@ import React, {
   useRef
 } from 'react'
 
-export interface monacoHandles {
+export interface MonacoHandles {
   getValue: () => string
   setValue: (value: string) => void
-  dispose: () => void
 }
 
-const Monaco = forwardRef<monacoHandles, any>(
-  (_props, ref): JSX.Element => {
+interface MonacoProps {
+  id: string
+}
+
+const Monaco = forwardRef<MonacoHandles, MonacoProps>(
+  (props: MonacoProps, ref): JSX.Element => {
     const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
+    const id = `monaco-${props.id}`
 
     useEffect(() => {
       editorRef.current = monaco.editor.create(
-        document.getElementById('mon-editor') as HTMLElement,
+        document.getElementById(id) as HTMLElement,
         { automaticLayout: true }
       )
 
-      editorRef.current.onDidChangeModelContent(() => {
-        console.log(editorRef.current?.getValue())
-      })
-
       return () => {
         editorRef.current?.dispose()
       }
@@ -57,13 +57,10 @@ const Monaco = forwardRef<monacoHandles, any>(
       },
       setValue(value) {
         editorRef.current?.setValue(value)
-      },
-      dispose() {
-        editorRef.current?.dispose()
       }
     }))
 
-    return <div id="mon-editor" style={{ height: 'auto', width: '100%' }} />
+    return <div id={id} style={{ height: 'auto', width: '100%' }} />
   }
 )
 
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index 11e8b706cde..7d1ddfa73d7 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -18,10 +18,10 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import React, { Dispatch, useRef } from 'react'
+import React, { Dispatch, useEffect, useRef } from 'react'
 import { connect } from 'react-redux'
 import { Action } from 'redux'
-import Monaco, { monacoHandles } from '../Editor/Monaco'
+import Monaco, { MonacoHandles } from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
 import { executeCommand } from 'shared/modules/commands/commandsDuck'
 import { Frame } from 'shared/modules/stream/streamDuck'
@@ -32,11 +32,15 @@ interface EditFrameProps {
 }
 
 const EditFrame = ({ frame, runQuery }: EditFrameProps): JSX.Element => {
-  const monaco = useRef<monacoHandles>(null)
+  const monaco = useRef<MonacoHandles>(null)
+
+  useEffect(() => {
+    monaco.current?.setValue(frame.query)
+  }, [])
 
   return (
     <FrameTemplate
-      contents={<Monaco ref={monaco}></Monaco>}
+      contents={<Monaco ref={monaco} id={frame.id}></Monaco>}
       header={frame}
       runQuery={() => {
         const value = monaco.current?.getValue() || ''

From e8abef717a47664dec80e181e3b64c042c36d0b6 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Thu, 17 Sep 2020 15:19:24 +0200
Subject: [PATCH 07/23] set monaco theme according to app theme

---
 src/browser/modules/Editor/Monaco.tsx    | 10 ++++++
 src/browser/modules/Stream/EditFrame.tsx | 39 ++++++++++++++++++++----
 src/shared/modules/stream/streamDuck.ts  |  2 +-
 3 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index bde47e9ee8b..ced0d0876f3 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -25,14 +25,18 @@ import React, {
   useImperativeHandle,
   useRef
 } from 'react'
+import { Theme } from '../Stream/EditFrame'
 
 export interface MonacoHandles {
   getValue: () => string
   setValue: (value: string) => void
+  setOptions: (options: monaco.editor.IGlobalEditorOptions) => void
+  setTheme: (theme: string) => void
 }
 
 interface MonacoProps {
   id: string
+  theme: Theme
 }
 
 const Monaco = forwardRef<MonacoHandles, MonacoProps>(
@@ -57,6 +61,12 @@ const Monaco = forwardRef<MonacoHandles, MonacoProps>(
       },
       setValue(value) {
         editorRef.current?.setValue(value)
+      },
+      setOptions(options) {
+        editorRef.current?.updateOptions(options)
+      },
+      setTheme(theme) {
+        monaco.editor.setTheme(theme)
       }
     }))
 
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index 7d1ddfa73d7..d0ddd003c05 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -24,23 +24,47 @@ import { Action } from 'redux'
 import Monaco, { MonacoHandles } from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
 import { executeCommand } from 'shared/modules/commands/commandsDuck'
-import { Frame } from 'shared/modules/stream/streamDuck'
+import {
+  DARK_THEME,
+  getTheme,
+  LIGHT_THEME,
+  OUTLINE_THEME
+} from 'shared/modules/settings/settingsDuck'
+import { Frame, GlobalState } from 'shared/modules/stream/streamDuck'
+import useDerivedTheme from 'browser-hooks/useDerivedTheme'
+
+export type Theme =
+  | typeof LIGHT_THEME
+  | typeof OUTLINE_THEME
+  | typeof DARK_THEME
 
 interface EditFrameProps {
   frame: Frame
   runQuery: (query: string) => void
+  theme: Theme
 }
 
-const EditFrame = ({ frame, runQuery }: EditFrameProps): JSX.Element => {
+const EditFrame = ({ frame, runQuery, theme }: EditFrameProps): JSX.Element => {
   const monaco = useRef<MonacoHandles>(null)
 
   useEffect(() => {
     monaco.current?.setValue(frame.query)
   }, [])
 
+  const [derivedTheme] = useDerivedTheme(theme, LIGHT_THEME) as [Theme]
+
+  useEffect(() => {
+    const themeMap = {
+      [LIGHT_THEME]: 'vs',
+      [OUTLINE_THEME]: 'hc-black',
+      [DARK_THEME]: 'vs-dark'
+    }
+    monaco.current?.setTheme(themeMap[derivedTheme])
+  }, [derivedTheme])
+
   return (
     <FrameTemplate
-      contents={<Monaco ref={monaco} id={frame.id}></Monaco>}
+      contents={<Monaco ref={monaco} id={frame.id} theme={theme}></Monaco>}
       header={frame}
       runQuery={() => {
         const value = monaco.current?.getValue() || ''
@@ -50,11 +74,14 @@ const EditFrame = ({ frame, runQuery }: EditFrameProps): JSX.Element => {
   )
 }
 
+const mapStateToProps = (state: GlobalState) => ({
+  theme: getTheme(state)
+})
+
 const mapDispatchToProps = (dispatch: Dispatch<Action>) => ({
-  runQuery: (query: string) => {
+  runQuery(query: string) {
     dispatch(executeCommand(query))
-    // todo update query and cmd in store.frames?
   }
 })
 
-export default connect(null, mapDispatchToProps)(EditFrame)
+export default connect(mapStateToProps, mapDispatchToProps)(EditFrame)
diff --git a/src/shared/modules/stream/streamDuck.ts b/src/shared/modules/stream/streamDuck.ts
index 18302a7b69d..ded14f719d7 100644
--- a/src/shared/modules/stream/streamDuck.ts
+++ b/src/shared/modules/stream/streamDuck.ts
@@ -38,7 +38,7 @@ export const UNPIN = 'frames/UNPIN'
 export const SET_RECENT_VIEW = 'frames/SET_RECENT_VIEW'
 export const SET_MAX_FRAMES = 'frames/SET_MAX_FRAMES'
 
-interface GlobalState {
+export interface GlobalState {
   [NAME]: FramesState
 }
 

From 867c3c733f6ce2f96956ba0a938ce8e560e4a0c5 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Thu, 17 Sep 2020 18:30:35 +0200
Subject: [PATCH 08/23] set monaco config options

---
 src/browser/modules/Editor/Monaco.tsx    | 17 ++++++++++++++---
 src/browser/modules/Stream/EditFrame.tsx |  8 +++-----
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index ced0d0876f3..be30b635534 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -25,7 +25,6 @@ import React, {
   useImperativeHandle,
   useRef
 } from 'react'
-import { Theme } from '../Stream/EditFrame'
 
 export interface MonacoHandles {
   getValue: () => string
@@ -36,7 +35,7 @@ export interface MonacoHandles {
 
 interface MonacoProps {
   id: string
-  theme: Theme
+  value: string
 }
 
 const Monaco = forwardRef<MonacoHandles, MonacoProps>(
@@ -47,7 +46,19 @@ const Monaco = forwardRef<MonacoHandles, MonacoProps>(
     useEffect(() => {
       editorRef.current = monaco.editor.create(
         document.getElementById(id) as HTMLElement,
-        { automaticLayout: true }
+        {
+          automaticLayout: true,
+          contextmenu: false,
+          cursorStyle: 'block',
+          fontSize: 16,
+          lightbulb: { enabled: false },
+          links: false,
+          minimap: { enabled: false },
+          scrollBeyondLastColumn: 0,
+          scrollBeyondLastLine: false,
+          value: props.value,
+          wordWrap: 'on'
+        }
       )
 
       return () => {
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index d0ddd003c05..9042f7fc141 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -47,10 +47,6 @@ interface EditFrameProps {
 const EditFrame = ({ frame, runQuery, theme }: EditFrameProps): JSX.Element => {
   const monaco = useRef<MonacoHandles>(null)
 
-  useEffect(() => {
-    monaco.current?.setValue(frame.query)
-  }, [])
-
   const [derivedTheme] = useDerivedTheme(theme, LIGHT_THEME) as [Theme]
 
   useEffect(() => {
@@ -64,7 +60,9 @@ const EditFrame = ({ frame, runQuery, theme }: EditFrameProps): JSX.Element => {
 
   return (
     <FrameTemplate
-      contents={<Monaco ref={monaco} id={frame.id} theme={theme}></Monaco>}
+      contents={
+        <Monaco id={frame.id} ref={monaco} value={frame.query}></Monaco>
+      }
       header={frame}
       runQuery={() => {
         const value = monaco.current?.getValue() || ''

From dd2547fe4cb52f4ef69ac52971ef5bc3ff8e4a6b Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Fri, 18 Sep 2020 10:34:25 +0200
Subject: [PATCH 09/23] make editor in edit frame fill entire frame

---
 src/browser/modules/Editor/Monaco.tsx    | 10 +++++++-
 src/browser/modules/Stream/EditFrame.tsx | 30 ++++++++++++++++--------
 2 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index be30b635534..6b899b10c3b 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -81,7 +81,15 @@ const Monaco = forwardRef<MonacoHandles, MonacoProps>(
       }
     }))
 
-    return <div id={id} style={{ height: 'auto', width: '100%' }} />
+    return (
+      <div
+        id={id}
+        style={{
+          overflow: 'hidden',
+          width: '100%'
+        }}
+      />
+    )
   }
 )
 
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index 9042f7fc141..d760f12454f 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -21,8 +21,10 @@
 import React, { Dispatch, useEffect, useRef } from 'react'
 import { connect } from 'react-redux'
 import { Action } from 'redux'
+import styled from 'styled-components'
 import Monaco, { MonacoHandles } from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
+import { StyledFrameBody } from '../Frame/styled'
 import { executeCommand } from 'shared/modules/commands/commandsDuck'
 import {
   DARK_THEME,
@@ -44,6 +46,12 @@ interface EditFrameProps {
   theme: Theme
 }
 
+const ForceFullSizeFrameContent = styled.div`
+  ${StyledFrameBody} {
+    padding: 0;
+  }
+`
+
 const EditFrame = ({ frame, runQuery, theme }: EditFrameProps): JSX.Element => {
   const monaco = useRef<MonacoHandles>(null)
 
@@ -59,16 +67,18 @@ const EditFrame = ({ frame, runQuery, theme }: EditFrameProps): JSX.Element => {
   }, [derivedTheme])
 
   return (
-    <FrameTemplate
-      contents={
-        <Monaco id={frame.id} ref={monaco} value={frame.query}></Monaco>
-      }
-      header={frame}
-      runQuery={() => {
-        const value = monaco.current?.getValue() || ''
-        runQuery(value)
-      }}
-    />
+    <ForceFullSizeFrameContent>
+      <FrameTemplate
+        contents={
+          <Monaco id={frame.id} ref={monaco} value={frame.query}></Monaco>
+        }
+        header={frame}
+        runQuery={() => {
+          const value = monaco.current?.getValue() || ''
+          runQuery(value)
+        }}
+      />
+    </ForceFullSizeFrameContent>
   )
 }
 

From df3ac53dfcb02edd9430772a9dbd16f50f4280f6 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Mon, 21 Sep 2020 11:38:51 +0200
Subject: [PATCH 10/23] change monaco component api from ref to props

---
 src/browser/modules/Editor/Monaco.tsx    | 122 +++++++++++------------
 src/browser/modules/Stream/EditFrame.tsx |  47 +++++----
 2 files changed, 89 insertions(+), 80 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index 6b899b10c3b..52860099be2 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -19,78 +19,74 @@
  */
 
 import * as monaco from 'monaco-editor'
-import React, {
-  forwardRef,
-  useEffect,
-  useImperativeHandle,
-  useRef
-} from 'react'
+import React, { useEffect, useRef } from 'react'
 
-export interface MonacoHandles {
-  getValue: () => string
-  setValue: (value: string) => void
-  setOptions: (options: monaco.editor.IGlobalEditorOptions) => void
-  setTheme: (theme: string) => void
-}
+export const VS_LIGHT_THEME = 'vs'
+export const VS_DARK_THEME = 'vs-dark'
+export const VS_HIGH_CONTRAST_THEME = 'hc-black'
+
+export type VSTheme =
+  | typeof VS_LIGHT_THEME
+  | typeof VS_DARK_THEME
+  | typeof VS_HIGH_CONTRAST_THEME
 
 interface MonacoProps {
   id: string
-  value: string
+  value?: string
+  onChange?: (value: string) => void
+  options?: monaco.editor.IGlobalEditorOptions
+  theme?: VSTheme
 }
 
-const Monaco = forwardRef<MonacoHandles, MonacoProps>(
-  (props: MonacoProps, ref): JSX.Element => {
-    const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
-    const id = `monaco-${props.id}`
-
-    useEffect(() => {
-      editorRef.current = monaco.editor.create(
-        document.getElementById(id) as HTMLElement,
-        {
-          automaticLayout: true,
-          contextmenu: false,
-          cursorStyle: 'block',
-          fontSize: 16,
-          lightbulb: { enabled: false },
-          links: false,
-          minimap: { enabled: false },
-          scrollBeyondLastColumn: 0,
-          scrollBeyondLastLine: false,
-          value: props.value,
-          wordWrap: 'on'
-        }
-      )
+const Monaco = ({
+  id,
+  value = '',
+  onChange = () => undefined,
+  theme = VS_LIGHT_THEME
+}: MonacoProps): JSX.Element => {
+  const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
+  const monacoId = `monaco-${id}`
 
-      return () => {
-        editorRef.current?.dispose()
+  useEffect(() => {
+    editorRef.current = monaco.editor.create(
+      document.getElementById(monacoId) as HTMLElement,
+      {
+        automaticLayout: true,
+        contextmenu: false,
+        cursorStyle: 'block',
+        fontSize: 16,
+        lightbulb: { enabled: false },
+        links: false,
+        minimap: { enabled: false },
+        scrollBeyondLastColumn: 0,
+        scrollBeyondLastLine: false,
+        value: value,
+        wordWrap: 'on'
       }
-    }, [])
+    )
 
-    useImperativeHandle(ref, () => ({
-      getValue() {
-        return editorRef.current?.getValue() || ''
-      },
-      setValue(value) {
-        editorRef.current?.setValue(value)
-      },
-      setOptions(options) {
-        editorRef.current?.updateOptions(options)
-      },
-      setTheme(theme) {
-        monaco.editor.setTheme(theme)
-      }
-    }))
+    editorRef.current?.onDidChangeModelContent(() => {
+      onChange(editorRef.current?.getValue() || '')
+    })
 
-    return (
-      <div
-        id={id}
-        style={{
-          overflow: 'hidden',
-          width: '100%'
-        }}
-      />
-    )
-  }
-)
+    return () => {
+      editorRef.current?.dispose()
+    }
+  }, [])
+
+  useEffect(() => {
+    monaco.editor.setTheme(theme)
+  }, [theme])
+
+  return (
+    <div
+      id={monacoId}
+      style={{
+        overflow: 'hidden',
+        width: '100%'
+      }}
+    />
+  )
+}
 
 export default Monaco
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index d760f12454f..8cb588e6900 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -18,11 +18,16 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import React, { Dispatch, useEffect, useRef } from 'react'
+import React, { Dispatch, useEffect, useState } from 'react'
 import { connect } from 'react-redux'
 import { Action } from 'redux'
 import styled from 'styled-components'
-import Monaco, { MonacoHandles } from '../Editor/Monaco'
+import Monaco, {
+  VS_DARK_THEME,
+  VS_HIGH_CONTRAST_THEME,
+  VS_LIGHT_THEME,
+  VSTheme
+} from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
 import { StyledFrameBody } from '../Frame/styled'
 import { executeCommand } from 'shared/modules/commands/commandsDuck'
@@ -35,15 +40,15 @@ import {
 import { Frame, GlobalState } from 'shared/modules/stream/streamDuck'
 import useDerivedTheme from 'browser-hooks/useDerivedTheme'
 
-export type Theme =
+export type BrowserTheme =
   | typeof LIGHT_THEME
   | typeof OUTLINE_THEME
   | typeof DARK_THEME
 
 interface EditFrameProps {
+  browserTheme: BrowserTheme
   frame: Frame
   runQuery: (query: string) => void
-  theme: Theme
 }
 
 const ForceFullSizeFrameContent = styled.div`
@@ -52,30 +57,37 @@ const ForceFullSizeFrameContent = styled.div`
   }
 `
 
-const EditFrame = ({ frame, runQuery, theme }: EditFrameProps): JSX.Element => {
-  const monaco = useRef<MonacoHandles>(null)
+const EditFrame = (props: EditFrameProps): JSX.Element => {
+  const [text, setText] = useState(props.frame.query)
 
-  const [derivedTheme] = useDerivedTheme(theme, LIGHT_THEME) as [Theme]
+  const [derivedTheme] = useDerivedTheme(props.browserTheme, LIGHT_THEME) as [
+    BrowserTheme
+  ]
+  const [theme, setTheme] = useState<VSTheme>(VS_LIGHT_THEME)
 
   useEffect(() => {
-    const themeMap = {
-      [LIGHT_THEME]: 'vs',
-      [OUTLINE_THEME]: 'hc-black',
-      [DARK_THEME]: 'vs-dark'
+    const themeMap: { [key in BrowserTheme]: VSTheme } = {
+      [LIGHT_THEME]: VS_LIGHT_THEME,
+      [OUTLINE_THEME]: VS_DARK_THEME,
+      [DARK_THEME]: VS_HIGH_CONTRAST_THEME
     }
-    monaco.current?.setTheme(themeMap[derivedTheme])
+    setTheme(themeMap[derivedTheme])
   }, [derivedTheme])
 
   return (
     <ForceFullSizeFrameContent>
       <FrameTemplate
         contents={
-          <Monaco id={frame.id} ref={monaco} value={frame.query}></Monaco>
+          <Monaco
+            id={props.frame.id}
+            onChange={setText}
+            theme={theme}
+            value={text}
+          ></Monaco>
         }
-        header={frame}
+        header={props.frame}
         runQuery={() => {
-          const value = monaco.current?.getValue() || ''
-          runQuery(value)
+          props.runQuery(text)
         }}
       />
     </ForceFullSizeFrameContent>
@@ -83,12 +95,13 @@ const EditFrame = ({ frame, runQuery, theme }: EditFrameProps): JSX.Element => {
 }
 
 const mapStateToProps = (state: GlobalState) => ({
-  theme: getTheme(state)
+  browserTheme: getTheme(state)
 })
 
 const mapDispatchToProps = (dispatch: Dispatch<Action>) => ({
   runQuery(query: string) {
     dispatch(executeCommand(query))
+    // TODO: dispatch update frame.query with text
   }
 })
 

From 336f09388414c2b32a843025f101305878671123 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Mon, 28 Sep 2020 09:38:42 +0200
Subject: [PATCH 11/23] add cypher syntax highlighting in monaco

---
 package.json                                  |     2 +
 src/browser/modules/Editor/Monaco.tsx         |   147 +-
 .../Editor/antlr-cypher-parser/CypherLexer.js |  1670 ++
 .../antlr-cypher-parser/CypherListener.js     |  1268 +
 .../antlr-cypher-parser/CypherParser.js       | 24555 ++++++++++++++++
 .../CypherTokensProvider.ts                   |    94 +
 .../antlr-cypher-parser/ParserFacade.ts       |   148 +
 src/browser/modules/Stream/EditFrame.tsx      |     5 +-
 yarn.lock                                     |    10 +
 9 files changed, 27896 insertions(+), 3 deletions(-)
 create mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js
 create mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js
 create mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js
 create mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
 create mode 100644 src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts

diff --git a/package.json b/package.json
index bd0d37b6918..77334ccafb5 100644
--- a/package.json
+++ b/package.json
@@ -69,6 +69,7 @@
     "@testing-library/jest-dom": "^5.3.0",
     "@testing-library/react": "^9.0.1",
     "@testing-library/react-hooks": "^2.0.1",
+    "@types/antlr4": "^4.7.2",
     "@types/apollo-upload-client": "^14.1.0",
     "@types/jest": "^24.9.0",
     "@types/lodash-es": "^4.17.3",
@@ -151,6 +152,7 @@
     "@relate-by-ui/css": "1.0.5",
     "@relate-by-ui/relatable": "1.0.1",
     "@relate-by-ui/saved-scripts": "^1.0.5",
+    "antlr4": "^4.8.0",
     "apollo-upload-client": "^14.1.2",
     "ascii-data-table": "^2.1.1",
     "canvg": "^1.5.3",
diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index 52860099be2..c94a22027f3 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -20,6 +20,7 @@
 
 import * as monaco from 'monaco-editor'
 import React, { useEffect, useRef } from 'react'
+import { CypherTokensProvider } from './antlr-cypher-parser/CypherTokensProvider'
 
 export const VS_LIGHT_THEME = 'vs'
 export const VS_DARK_THEME = 'vs-dark'
@@ -48,6 +49,148 @@ const Monaco = ({
   const monacoId = `monaco-${id}`
 
   useEffect(() => {
+    monaco.languages.register({ id: 'cypher' })
+    monaco.languages.setTokensProvider('cypher', new CypherTokensProvider())
+
+    // colors from cypher-editor/cypher-codemirror/src/css/_solarized.css
+    const enum Color {
+      blue = '#268bd2',
+      cyan = '#2aa198',
+      cyan_grey = '#586e75',
+      green = '#859900',
+      light_grey = '#93a1a1',
+      magenta = '#d33682',
+      orange = '#cb4b16',
+      red = '#dc322f',
+      violet = '#6c71c4',
+      yellow = '#b58900'
+    }
+
+    // syntax highlighting from cypher-editor/cypher-codemirror/src/css/syntax.css
+    const rules = [
+      // { token: 'p-label', foreGround: Color.orange },
+      // { token: 'p-relationshipType', foreGround: Color.orange },
+      // { token: 'p-variable', foreGround: Color.blue },
+      // { token: 'p-procedure', foreGround: Color.violet },
+      // { token: 'p-function', foreGround: Color.violet },
+      // {
+      //   token: 'p-parameter',
+      //   foreGround: Color.red
+      // },
+      // { token: 'p-property', foreGround: Color.cyan_grey },
+      // {
+      //   token: 's-cypher s-cypher-dark  p-property',
+      //   foreGround: Color.light_grey
+      // },
+      // { token: 'p-consoleCommand', foreGround: Color.magenta },
+      // { token: 'p-procedureOutput', foreGround: Color.blue },
+
+      ...[
+        'all',
+        'allshortestpaths',
+        'and',
+        'any',
+        'as',
+        'asc',
+        'ascending',
+        'assert',
+        'by',
+        'call',
+        'case',
+        'commit',
+        'constraint',
+        'contains',
+        'count',
+        'create',
+        'csv',
+        'cypher',
+        'delete',
+        'desc',
+        'descending',
+        'detach',
+        'distinct',
+        'drop',
+        'else',
+        'end',
+        'ends',
+        'enterrule',
+        'exists',
+        'exitrule',
+        'explain',
+        'extract',
+        'false',
+        'fieldterminator',
+        'filter',
+        'foreach',
+        'from',
+        'headers',
+        'in',
+        'index',
+        'is',
+        'join',
+        'key',
+        'l_skip',
+        'limit',
+        'load',
+        'match',
+        'merge',
+        'node',
+        'none',
+        'not',
+        'null',
+        'on',
+        'optional',
+        'or',
+        'order',
+        'periodic',
+        'profile',
+        'reduce',
+        'rel',
+        'relationship',
+        'remove',
+        'return',
+        'scan',
+        'set',
+        'shortestpath',
+        'single',
+        'start',
+        'starts',
+        'then',
+        'true',
+        'union',
+        'unique',
+        'unwind',
+        'using',
+        'when',
+        'where',
+        'with',
+        'xor',
+        'yield'
+      ].map((keyword: string) => ({
+        token: `${keyword}.cypher`,
+        foreground: Color.green
+      })),
+      ...['regulardecimalreal.cypher', 'decimalinteger.cypher'].map(token => ({
+        token,
+        foreground: Color.cyan
+      })),
+      { token: 'stringliteral.cypher', foreground: Color.yellow }
+    ]
+
+    // Use colors and rules, only add default foreground and background colors
+    monaco.editor.defineTheme(VS_LIGHT_THEME, {
+      base: VS_LIGHT_THEME,
+      inherit: false,
+      rules: [...rules, { token: 'sp.cypher', foreground: Color.light_grey }],
+      colors: {}
+    })
+    monaco.editor.defineTheme(VS_DARK_THEME, {
+      base: VS_DARK_THEME,
+      inherit: false,
+      rules: [...rules, { token: 'sp.cypher', foreground: Color.cyan_grey }],
+      colors: {}
+    })
+
     editorRef.current = monaco.editor.create(
       document.getElementById(monacoId) as HTMLElement,
       {
@@ -55,12 +198,14 @@ const Monaco = ({
         contextmenu: false,
         cursorStyle: 'block',
         fontSize: 16,
+        language: 'cypher',
         lightbulb: { enabled: false },
         links: false,
         minimap: { enabled: false },
         scrollBeyondLastColumn: 0,
         scrollBeyondLastLine: false,
-        value: value,
+        theme: VS_LIGHT_THEME,
+        value,
         wordWrap: 'on'
       }
     )
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js b/src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js
new file mode 100644
index 00000000000..36296c2a512
--- /dev/null
+++ b/src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js
@@ -0,0 +1,1670 @@
+// Generated from cypher-editor-support/src/_generated/Cypher.g4 by ANTLR 4.7
+// jshint ignore: start
+var antlr4 = require('antlr4')
+
+var serializedATN = [
+  '\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964',
+  '\u0002\u009c\u050f\b\u0001\u0004\u0002\t\u0002\u0004\u0003\t\u0003\u0004',
+  '\u0004\t\u0004\u0004\u0005\t\u0005\u0004\u0006\t\u0006\u0004\u0007\t',
+  '\u0007\u0004\b\t\b\u0004\t\t\t\u0004\n\t\n\u0004\u000b\t\u000b\u0004',
+  '\f\t\f\u0004\r\t\r\u0004\u000e\t\u000e\u0004\u000f\t\u000f\u0004\u0010',
+  '\t\u0010\u0004\u0011\t\u0011\u0004\u0012\t\u0012\u0004\u0013\t\u0013',
+  '\u0004\u0014\t\u0014\u0004\u0015\t\u0015\u0004\u0016\t\u0016\u0004\u0017',
+  '\t\u0017\u0004\u0018\t\u0018\u0004\u0019\t\u0019\u0004\u001a\t\u001a',
+  '\u0004\u001b\t\u001b\u0004\u001c\t\u001c\u0004\u001d\t\u001d\u0004\u001e',
+  '\t\u001e\u0004\u001f\t\u001f\u0004 \t \u0004!\t!\u0004"\t"\u0004#',
+  "\t#\u0004$\t$\u0004%\t%\u0004&\t&\u0004'\t'\u0004(\t(\u0004)\t)\u0004",
+  '*\t*\u0004+\t+\u0004,\t,\u0004-\t-\u0004.\t.\u0004/\t/\u00040\t0\u0004',
+  '1\t1\u00042\t2\u00043\t3\u00044\t4\u00045\t5\u00046\t6\u00047\t7\u0004',
+  '8\t8\u00049\t9\u0004:\t:\u0004;\t;\u0004<\t<\u0004=\t=\u0004>\t>\u0004',
+  '?\t?\u0004@\t@\u0004A\tA\u0004B\tB\u0004C\tC\u0004D\tD\u0004E\tE\u0004',
+  'F\tF\u0004G\tG\u0004H\tH\u0004I\tI\u0004J\tJ\u0004K\tK\u0004L\tL\u0004',
+  'M\tM\u0004N\tN\u0004O\tO\u0004P\tP\u0004Q\tQ\u0004R\tR\u0004S\tS\u0004',
+  'T\tT\u0004U\tU\u0004V\tV\u0004W\tW\u0004X\tX\u0004Y\tY\u0004Z\tZ\u0004',
+  '[\t[\u0004\\\t\\\u0004]\t]\u0004^\t^\u0004_\t_\u0004`\t`\u0004a\ta\u0004',
+  'b\tb\u0004c\tc\u0004d\td\u0004e\te\u0004f\tf\u0004g\tg\u0004h\th\u0004',
+  'i\ti\u0004j\tj\u0004k\tk\u0004l\tl\u0004m\tm\u0004n\tn\u0004o\to\u0004',
+  'p\tp\u0004q\tq\u0004r\tr\u0004s\ts\u0004t\tt\u0004u\tu\u0004v\tv\u0004',
+  'w\tw\u0004x\tx\u0004y\ty\u0004z\tz\u0004{\t{\u0004|\t|\u0004}\t}\u0004',
+  '~\t~\u0004\u007f\t\u007f\u0004\u0080\t\u0080\u0004\u0081\t\u0081\u0004',
+  '\u0082\t\u0082\u0004\u0083\t\u0083\u0004\u0084\t\u0084\u0004\u0085\t',
+  '\u0085\u0004\u0086\t\u0086\u0004\u0087\t\u0087\u0004\u0088\t\u0088\u0004',
+  '\u0089\t\u0089\u0004\u008a\t\u008a\u0004\u008b\t\u008b\u0004\u008c\t',
+  '\u008c\u0004\u008d\t\u008d\u0004\u008e\t\u008e\u0004\u008f\t\u008f\u0004',
+  '\u0090\t\u0090\u0004\u0091\t\u0091\u0004\u0092\t\u0092\u0004\u0093\t',
+  '\u0093\u0004\u0094\t\u0094\u0004\u0095\t\u0095\u0004\u0096\t\u0096\u0004',
+  '\u0097\t\u0097\u0004\u0098\t\u0098\u0004\u0099\t\u0099\u0004\u009a\t',
+  '\u009a\u0004\u009b\t\u009b\u0004\u009c\t\u009c\u0004\u009d\t\u009d\u0004',
+  '\u009e\t\u009e\u0004\u009f\t\u009f\u0004\u00a0\t\u00a0\u0004\u00a1\t',
+  '\u00a1\u0004\u00a2\t\u00a2\u0004\u00a3\t\u00a3\u0004\u00a4\t\u00a4\u0004',
+  '\u00a5\t\u00a5\u0004\u00a6\t\u00a6\u0004\u00a7\t\u00a7\u0004\u00a8\t',
+  '\u00a8\u0004\u00a9\t\u00a9\u0004\u00aa\t\u00aa\u0004\u00ab\t\u00ab\u0004',
+  '\u00ac\t\u00ac\u0004\u00ad\t\u00ad\u0004\u00ae\t\u00ae\u0004\u00af\t',
+  '\u00af\u0004\u00b0\t\u00b0\u0004\u00b1\t\u00b1\u0004\u00b2\t\u00b2\u0004',
+  '\u00b3\t\u00b3\u0004\u00b4\t\u00b4\u0004\u00b5\t\u00b5\u0004\u00b6\t',
+  '\u00b6\u0004\u00b7\t\u00b7\u0004\u00b8\t\u00b8\u0004\u00b9\t\u00b9\u0004',
+  '\u00ba\t\u00ba\u0004\u00bb\t\u00bb\u0004\u00bc\t\u00bc\u0004\u00bd\t',
+  '\u00bd\u0004\u00be\t\u00be\u0004\u00bf\t\u00bf\u0004\u00c0\t\u00c0\u0004',
+  '\u00c1\t\u00c1\u0004\u00c2\t\u00c2\u0003\u0002\u0003\u0002\u0003\u0003',
+  '\u0003\u0003\u0003\u0004\u0003\u0004\u0003\u0005\u0003\u0005\u0003\u0005',
+  '\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0007\u0003\u0007',
+  '\u0003\b\u0003\b\u0003\t\u0003\t\u0003\n\u0003\n\u0003\u000b\u0003\u000b',
+  '\u0003\f\u0003\f\u0003\r\u0003\r\u0003\u000e\u0003\u000e\u0003\u000f',
+  '\u0003\u000f\u0003\u0010\u0003\u0010\u0003\u0011\u0003\u0011\u0003\u0012',
+  '\u0003\u0012\u0003\u0013\u0003\u0013\u0003\u0014\u0003\u0014\u0003\u0015',
+  '\u0003\u0015\u0003\u0016\u0003\u0016\u0003\u0016\u0003\u0017\u0003\u0017',
+  '\u0003\u0018\u0003\u0018\u0003\u0019\u0003\u0019\u0003\u0019\u0003\u001a',
+  '\u0003\u001a\u0003\u001b\u0003\u001b\u0003\u001c\u0003\u001c\u0003\u001c',
+  '\u0003\u001d\u0003\u001d\u0003\u001d\u0003\u001e\u0003\u001e\u0003\u001e',
+  '\u0003\u001f\u0003\u001f\u0003 \u0003 \u0003!\u0003!\u0003!\u0003"',
+  '\u0003"\u0003"\u0003#\u0003#\u0003$\u0003$\u0003%\u0003%\u0003&\u0003',
+  "&\u0003'\u0003'\u0003(\u0003(\u0003)\u0003)\u0003*\u0003*\u0003+\u0003",
+  '+\u0003,\u0003,\u0003-\u0003-\u0003.\u0003.\u0003/\u0003/\u00030\u0003',
+  '0\u00031\u00031\u00032\u00032\u00033\u00033\u00034\u00034\u00035\u0003',
+  '5\u00036\u00036\u00037\u00037\u00037\u00037\u00037\u00037\u00037\u0003',
+  '8\u00038\u00038\u00038\u00038\u00038\u00038\u00038\u00039\u00039\u0003',
+  '9\u00039\u00039\u00039\u00039\u00039\u0003:\u0003:\u0003:\u0003:\u0003',
+  ':\u0003:\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003',
+  ';\u0003<\u0003<\u0003<\u0003<\u0003<\u0003<\u0003<\u0003=\u0003=\u0003',
+  '=\u0003=\u0003=\u0003=\u0003>\u0003>\u0003>\u0003>\u0003?\u0003?\u0003',
+  '?\u0003?\u0003?\u0003?\u0003?\u0003@\u0003@\u0003@\u0003@\u0003@\u0003',
+  'A\u0003A\u0003A\u0003A\u0003A\u0003A\u0003B\u0003B\u0003B\u0003C\u0003',
+  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003',
+  'D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003E\u0003E\u0003E\u0003',
+  'F\u0003F\u0003F\u0003F\u0003F\u0003F\u0003F\u0003G\u0003G\u0003G\u0003',
+  'G\u0003G\u0003G\u0003G\u0003H\u0003H\u0003H\u0003H\u0003H\u0003I\u0003',
+  'I\u0003I\u0003I\u0003J\u0003J\u0003J\u0003J\u0003J\u0003K\u0003K\u0003',
+  'K\u0003K\u0003K\u0003K\u0003K\u0003K\u0003L\u0003L\u0003L\u0003L\u0003',
+  'L\u0003M\u0003M\u0003M\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003',
+  'N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003',
+  'O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003P\u0003',
+  'P\u0003P\u0003P\u0003P\u0003P\u0003Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003',
+  'Q\u0003Q\u0003R\u0003R\u0003R\u0003R\u0003R\u0003R\u0003S\u0003S\u0003',
+  'S\u0003S\u0003T\u0003T\u0003T\u0003T\u0003T\u0003T\u0003T\u0003U\u0003',
+  'U\u0003U\u0003U\u0003U\u0003U\u0003U\u0003V\u0003V\u0003V\u0003V\u0003',
+  'V\u0003V\u0003V\u0003W\u0003W\u0003W\u0003W\u0003W\u0003W\u0003W\u0003',
+  'W\u0003X\u0003X\u0003X\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003',
+  'Y\u0003Y\u0003Y\u0003Z\u0003Z\u0003Z\u0003Z\u0003Z\u0003Z\u0003Z\u0003',
+  '[\u0003[\u0003[\u0003[\u0003[\u0003[\u0003\\\u0003\\\u0003\\\u0003]',
+  '\u0003]\u0003]\u0003]\u0003]\u0003^\u0003^\u0003^\u0003^\u0003^\u0003',
+  '^\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003',
+  '_\u0003`\u0003`\u0003`\u0003`\u0003a\u0003a\u0003a\u0003a\u0003a\u0003',
+  'a\u0003a\u0003a\u0003a\u0003a\u0003a\u0003b\u0003b\u0003b\u0003b\u0003',
+  'b\u0003c\u0003c\u0003c\u0003c\u0003c\u0003d\u0003d\u0003d\u0003d\u0003',
+  'd\u0003e\u0003e\u0003e\u0003e\u0003e\u0003e\u0003f\u0003f\u0003f\u0003',
+  'f\u0003f\u0003g\u0003g\u0003g\u0003g\u0003g\u0003g\u0003g\u0003g\u0003',
+  'g\u0003g\u0003g\u0003g\u0003g\u0003h\u0003h\u0003h\u0003h\u0003i\u0003',
+  'i\u0003i\u0003i\u0003i\u0003i\u0003j\u0003j\u0003j\u0003j\u0003j\u0003',
+  'j\u0003j\u0003j\u0003j\u0003j\u0003j\u0003j\u0003j\u0003k\u0003k\u0003',
+  'k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003',
+  'k\u0003k\u0003k\u0003k\u0003k\u0003l\u0003l\u0003l\u0003m\u0003m\u0003',
+  'm\u0003m\u0003n\u0003n\u0003n\u0003n\u0003o\u0003o\u0003o\u0003o\u0003',
+  'p\u0003p\u0003p\u0003p\u0003p\u0003p\u0003p\u0003q\u0003q\u0003q\u0003',
+  'q\u0003q\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003',
+  'r\u0003s\u0003s\u0003s\u0003s\u0003s\u0003t\u0003t\u0003t\u0003t\u0003',
+  't\u0003t\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003v\u0003',
+  'v\u0003v\u0003v\u0003v\u0003v\u0003v\u0003v\u0003w\u0003w\u0003w\u0003',
+  'w\u0003x\u0003x\u0003x\u0003x\u0003x\u0003y\u0003y\u0003y\u0003y\u0003',
+  'y\u0003y\u0003y\u0003z\u0003z\u0003z\u0003z\u0003z\u0003{\u0003{\u0003',
+  '{\u0003{\u0003{\u0003{\u0003|\u0003|\u0003|\u0003|\u0003|\u0003|\u0003',
+  '|\u0003}\u0003}\u0003}\u0003}\u0003}\u0003~\u0003~\u0003~\u0003~\u0003',
+  '~\u0003\u007f\u0003\u007f\u0003\u007f\u0003\u007f\u0003\u0080\u0003',
+  '\u0080\u0003\u0080\u0003\u0080\u0003\u0080\u0003\u0081\u0003\u0081\u0003',
+  '\u0081\u0003\u0081\u0003\u0081\u0003\u0082\u0003\u0082\u0003\u0082\u0003',
+  '\u0082\u0003\u0082\u0003\u0083\u0003\u0083\u0003\u0083\u0003\u0083\u0003',
+  '\u0083\u0003\u0083\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003',
+  '\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0005\u0085\u03ef',
+  '\n\u0085\u0007\u0085\u03f1\n\u0085\f\u0085\u000e\u0085\u03f4\u000b\u0085',
+  '\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085',
+  '\u0005\u0085\u03fc\n\u0085\u0007\u0085\u03fe\n\u0085\f\u0085\u000e\u0085',
+  '\u0401\u000b\u0085\u0003\u0085\u0005\u0085\u0404\n\u0085\u0003\u0086',
+  '\u0003\u0086\u0003\u0086\u0006\u0086\u0409\n\u0086\r\u0086\u000e\u0086',
+  '\u040a\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003',
+  '\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003',
+  '\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003',
+  '\u0087\u0005\u0087\u041f\n\u0087\u0003\u0088\u0003\u0088\u0003\u0088',
+  '\u0003\u0088\u0006\u0088\u0425\n\u0088\r\u0088\u000e\u0088\u0426\u0003',
+  '\u0089\u0003\u0089\u0003\u0089\u0007\u0089\u042c\n\u0089\f\u0089\u000e',
+  '\u0089\u042f\u000b\u0089\u0005\u0089\u0431\n\u0089\u0003\u008a\u0003',
+  '\u008a\u0006\u008a\u0435\n\u008a\r\u008a\u000e\u008a\u0436\u0003\u008b',
+  '\u0005\u008b\u043a\n\u008b\u0003\u008c\u0003\u008c\u0005\u008c\u043e',
+  '\n\u008c\u0003\u008d\u0003\u008d\u0005\u008d\u0442\n\u008d\u0003\u008e',
+  '\u0003\u008e\u0005\u008e\u0446\n\u008e\u0003\u008f\u0003\u008f\u0003',
+  '\u0090\u0003\u0090\u0005\u0090\u044c\n\u0090\u0003\u0091\u0003\u0091',
+  '\u0003\u0092\u0006\u0092\u0451\n\u0092\r\u0092\u000e\u0092\u0452\u0003',
+  '\u0092\u0006\u0092\u0456\n\u0092\r\u0092\u000e\u0092\u0457\u0003\u0092',
+  '\u0003\u0092\u0006\u0092\u045c\n\u0092\r\u0092\u000e\u0092\u045d\u0003',
+  '\u0092\u0003\u0092\u0006\u0092\u0462\n\u0092\r\u0092\u000e\u0092\u0463',
+  '\u0005\u0092\u0466\n\u0092\u0003\u0092\u0003\u0092\u0005\u0092\u046a',
+  '\n\u0092\u0003\u0092\u0006\u0092\u046d\n\u0092\r\u0092\u000e\u0092\u046e',
+  '\u0003\u0093\u0007\u0093\u0472\n\u0093\f\u0093\u000e\u0093\u0475\u000b',
+  '\u0093\u0003\u0093\u0003\u0093\u0006\u0093\u0479\n\u0093\r\u0093\u000e',
+  '\u0093\u047a\u0003\u0094\u0003\u0094\u0007\u0094\u047f\n\u0094\f\u0094',
+  '\u000e\u0094\u0482\u000b\u0094\u0003\u0095\u0003\u0095\u0005\u0095\u0486',
+  '\n\u0095\u0003\u0096\u0003\u0096\u0005\u0096\u048a\n\u0096\u0003\u0097',
+  '\u0003\u0097\u0003\u0097\u0003\u0097\u0007\u0097\u0490\n\u0097\f\u0097',
+  '\u000e\u0097\u0493\u000b\u0097\u0003\u0097\u0003\u0097\u0003\u0098\u0006',
+  '\u0098\u0498\n\u0098\r\u0098\u000e\u0098\u0499\u0003\u0099\u0003\u0099',
+  '\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099',
+  '\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0005\u0099\u04a8\n',
+  '\u0099\u0003\u009a\u0003\u009a\u0003\u009a\u0003\u009a\u0007\u009a\u04ae',
+  '\n\u009a\f\u009a\u000e\u009a\u04b1\u000b\u009a\u0003\u009a\u0003\u009a',
+  '\u0003\u009a\u0003\u009a\u0003\u009a\u0003\u009a\u0007\u009a\u04b9\n',
+  '\u009a\f\u009a\u000e\u009a\u04bc\u000b\u009a\u0005\u009a\u04be\n\u009a',
+  '\u0003\u009b\u0003\u009b\u0003\u009c\u0003\u009c\u0003\u009d\u0003\u009d',
+  '\u0003\u009e\u0003\u009e\u0003\u009f\u0003\u009f\u0003\u00a0\u0003\u00a0',
+  '\u0003\u00a1\u0003\u00a1\u0003\u00a2\u0003\u00a2\u0003\u00a3\u0003\u00a3',
+  '\u0003\u00a4\u0003\u00a4\u0003\u00a5\u0003\u00a5\u0003\u00a6\u0003\u00a6',
+  '\u0003\u00a7\u0003\u00a7\u0003\u00a8\u0003\u00a8\u0003\u00a9\u0003\u00a9',
+  '\u0003\u00aa\u0003\u00aa\u0003\u00ab\u0003\u00ab\u0003\u00ac\u0003\u00ac',
+  '\u0003\u00ad\u0003\u00ad\u0003\u00ae\u0003\u00ae\u0003\u00af\u0003\u00af',
+  '\u0003\u00b0\u0003\u00b0\u0003\u00b1\u0003\u00b1\u0003\u00b2\u0003\u00b2',
+  '\u0003\u00b3\u0003\u00b3\u0003\u00b4\u0003\u00b4\u0003\u00b5\u0003\u00b5',
+  '\u0003\u00b6\u0003\u00b6\u0003\u00b7\u0003\u00b7\u0003\u00b8\u0003\u00b8',
+  '\u0003\u00b9\u0003\u00b9\u0003\u00ba\u0003\u00ba\u0003\u00bb\u0003\u00bb',
+  '\u0003\u00bc\u0003\u00bc\u0003\u00bd\u0003\u00bd\u0003\u00be\u0003\u00be',
+  '\u0003\u00bf\u0003\u00bf\u0003\u00c0\u0003\u00c0\u0003\u00c1\u0003\u00c1',
+  '\u0003\u00c2\u0003\u00c2\u0003\u04af\u0002\u00c3\u0003\u0003\u0005\u0004',
+  '\u0007\u0005\t\u0006\u000b\u0007\r\b\u000f\t\u0011\n\u0013\u000b\u0015',
+  '\f\u0017\r\u0019\u000e\u001b\u000f\u001d\u0010\u001f\u0011!\u0012#\u0013',
+  "%\u0014'\u0015)\u0016+\u0017-\u0018/\u00191\u001a3\u001b5\u001c7\u001d",
+  '9\u001e;\u001f= ?!A"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]0_1a2c3e4g5i6k7m8o',
+  '9q:s;u<w=y>{?}@\u007fA\u0081B\u0083C\u0085D\u0087E\u0089F\u008bG\u008d',
+  'H\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1',
+  'R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5',
+  '\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5d\u00c7e\u00c9',
+  'f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9n\u00dbo\u00dd',
+  'p\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1',
+  'z\u00f3{\u00f5|\u00f7}\u00f9~\u00fb\u007f\u00fd\u0080\u00ff\u0081\u0101',
+  '\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\u0086\u010b\u0087\u010d',
+  '\u0088\u010f\u0089\u0111\u008a\u0113\u008b\u0115\u008c\u0117\u008d\u0119',
+  '\u008e\u011b\u008f\u011d\u0090\u011f\u0091\u0121\u0092\u0123\u0093\u0125',
+  '\u0094\u0127\u0095\u0129\u0096\u012b\u0097\u012d\u0098\u012f\u0099\u0131',
+  '\u009a\u0133\u009b\u0135\u009c\u0137\u0002\u0139\u0002\u013b\u0002\u013d',
+  '\u0002\u013f\u0002\u0141\u0002\u0143\u0002\u0145\u0002\u0147\u0002\u0149',
+  '\u0002\u014b\u0002\u014d\u0002\u014f\u0002\u0151\u0002\u0153\u0002\u0155',
+  '\u0002\u0157\u0002\u0159\u0002\u015b\u0002\u015d\u0002\u015f\u0002\u0161',
+  '\u0002\u0163\u0002\u0165\u0002\u0167\u0002\u0169\u0002\u016b\u0002\u016d',
+  '\u0002\u016f\u0002\u0171\u0002\u0173\u0002\u0175\u0002\u0177\u0002\u0179',
+  '\u0002\u017b\u0002\u017d\u0002\u017f\u0002\u0181\u0002\u0183\u0002\u0003',
+  '\u00022\u0004\u0002$$^^\u0004\u0002))^^\u0005\u00022;CHch\u000f\u0002',
+  '$$))DDHHPPTTVV^^ddhhppttvv\u0004\u0002WWww\u0004\u0002CHch\u0004\u0002',
+  'GGgg\b\u0002aa\u2041\u2042\u2056\u2056\ufe35\ufe36\ufe4f\ufe51\uff41',
+  '\uff41\u0003\u0002bb\n\u0002\u00a2\u00a2\u1682\u1682\u1810\u1810\u2002',
+  '\u200c\u202a\u202b\u2031\u2031\u2061\u2061\u3002\u3002\u0004\u0002\f',
+  '\f\u000f\u000f\u0003\u0002\u000e\u000e\u0003\u0002  \u01af\u00022;C',
+  '\\aac|\u00ac\u00ac\u00b7\u00b7\u00b9\u00b9\u00bc\u00bc\u00c2\u00d8\u00da',
+  '\u00f8\u00fa\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0\u0302',
+  '\u0376\u0378\u0379\u037c\u037f\u0388\u038c\u038e\u038e\u0390\u03a3\u03a5',
+  '\u03f7\u03f9\u0483\u0485\u0489\u048c\u0529\u0533\u0558\u055b\u055b\u0563',
+  '\u0589\u0593\u05bf\u05c1\u05c1\u05c3\u05c4\u05c6\u05c7\u05c9\u05c9\u05d2',
+  '\u05ec\u05f2\u05f4\u0612\u061c\u0622\u066b\u0670\u06d5\u06d7\u06de\u06e1',
+  '\u06ea\u06ec\u06fe\u0701\u0701\u0712\u074c\u074f\u07b3\u07c2\u07f7\u07fc',
+  '\u07fc\u0802\u082f\u0842\u085d\u08a2\u08a2\u08a4\u08ae\u08e6\u0900\u0902',
+  '\u0965\u0968\u0971\u0973\u0979\u097b\u0981\u0983\u0985\u0987\u098e\u0991',
+  '\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4\u09b8\u09bb\u09be\u09c6\u09c9',
+  '\u09ca\u09cd\u09d0\u09d9\u09d9\u09de\u09df\u09e1\u09e5\u09e8\u09f3\u0a03',
+  '\u0a05\u0a07\u0a0c\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37',
+  '\u0a38\u0a3a\u0a3b\u0a3e\u0a3e\u0a40\u0a44\u0a49\u0a4a\u0a4d\u0a4f\u0a53',
+  '\u0a53\u0a5b\u0a5e\u0a60\u0a60\u0a68\u0a77\u0a83\u0a85\u0a87\u0a8f\u0a91',
+  '\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4\u0ab5\u0ab7\u0abb\u0abe\u0ac7\u0ac9',
+  '\u0acb\u0acd\u0acf\u0ad2\u0ad2\u0ae2\u0ae5\u0ae8\u0af1\u0b03\u0b05\u0b07',
+  '\u0b0e\u0b11\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3e',
+  '\u0b46\u0b49\u0b4a\u0b4d\u0b4f\u0b58\u0b59\u0b5e\u0b5f\u0b61\u0b65\u0b68',
+  '\u0b71\u0b73\u0b73\u0b84\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b',
+  '\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0\u0bbb\u0bc0',
+  '\u0bc4\u0bc8\u0bca\u0bcc\u0bcf\u0bd2\u0bd2\u0bd9\u0bd9\u0be8\u0bf1\u0c03',
+  '\u0c05\u0c07\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c3f',
+  '\u0c46\u0c48\u0c4a\u0c4c\u0c4f\u0c57\u0c58\u0c5a\u0c5b\u0c62\u0c65\u0c68',
+  '\u0c71\u0c84\u0c85\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7',
+  '\u0cbb\u0cbe\u0cc6\u0cc8\u0cca\u0ccc\u0ccf\u0cd7\u0cd8\u0ce0\u0ce0\u0ce2',
+  '\u0ce5\u0ce8\u0cf1\u0cf3\u0cf4\u0d04\u0d05\u0d07\u0d0e\u0d10\u0d12\u0d14',
+  '\u0d3c\u0d3f\u0d46\u0d48\u0d4a\u0d4c\u0d50\u0d59\u0d59\u0d62\u0d65\u0d68',
+  '\u0d71\u0d7c\u0d81\u0d84\u0d85\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf',
+  '\u0dbf\u0dc2\u0dc8\u0dcc\u0dcc\u0dd1\u0dd6\u0dd8\u0dd8\u0dda\u0de1\u0df4',
+  '\u0df5\u0e03\u0e3c\u0e42\u0e50\u0e52\u0e5b\u0e83\u0e84\u0e86\u0e86\u0e89',
+  '\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7',
+  '\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0ebb\u0ebd\u0ebf\u0ec2\u0ec6\u0ec8',
+  '\u0ec8\u0eca\u0ecf\u0ed2\u0edb\u0ede\u0ee1\u0f02\u0f02\u0f1a\u0f1b\u0f22',
+  '\u0f2b\u0f37\u0f37\u0f39\u0f39\u0f3b\u0f3b\u0f40\u0f49\u0f4b\u0f6e\u0f73',
+  '\u0f86\u0f88\u0f99\u0f9b\u0fbe\u0fc8\u0fc8\u1002\u104b\u1052\u109f\u10a2',
+  '\u10c7\u10c9\u10c9\u10cf\u10cf\u10d2\u10fc\u10fe\u124a\u124c\u124f\u1252',
+  '\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4',
+  '\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312\u1314',
+  '\u1317\u131a\u135c\u135f\u1361\u136b\u1373\u1382\u1391\u13a2\u13f6\u1403',
+  '\u166e\u1671\u1681\u1683\u169c\u16a2\u16ec\u16f0\u16f2\u1702\u170e\u1710',
+  '\u1716\u1722\u1736\u1742\u1755\u1762\u176e\u1770\u1772\u1774\u1775\u1782',
+  '\u17d5\u17d9\u17d9\u17de\u17df\u17e2\u17eb\u180d\u180f\u1812\u181b\u1822',
+  '\u1879\u1882\u18ac\u18b2\u18f7\u1902\u191e\u1922\u192d\u1932\u193d\u1948',
+  '\u196f\u1972\u1976\u1982\u19ad\u19b2\u19cb\u19d2\u19dc\u1a02\u1a1d\u1a22',
+  '\u1a60\u1a62\u1a7e\u1a81\u1a8b\u1a92\u1a9b\u1aa9\u1aa9\u1b02\u1b4d\u1b52',
+  '\u1b5b\u1b6d\u1b75\u1b82\u1bf5\u1c02\u1c39\u1c42\u1c4b\u1c4f\u1c7f\u1cd2',
+  '\u1cd4\u1cd6\u1cf8\u1d02\u1de8\u1dfe\u1f17\u1f1a\u1f1f\u1f22\u1f47\u1f4a',
+  '\u1f4f\u1f52\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f7f\u1f82',
+  '\u1fb6\u1fb8\u1fbe\u1fc0\u1fc0\u1fc4\u1fc6\u1fc8\u1fce\u1fd2\u1fd5\u1fd8',
+  '\u1fdd\u1fe2\u1fee\u1ff4\u1ff6\u1ff8\u1ffe\u2041\u2042\u2056\u2056\u2073',
+  '\u2073\u2081\u2081\u2092\u209e\u20d2\u20de\u20e3\u20e3\u20e7\u20f2\u2104',
+  '\u2104\u2109\u2109\u210c\u2115\u2117\u2117\u211a\u211f\u2126\u2126\u2128',
+  '\u2128\u212a\u212a\u212c\u213b\u213e\u2141\u2147\u214b\u2150\u2150\u2162',
+  '\u218a\u2c02\u2c30\u2c32\u2c60\u2c62\u2ce6\u2ced\u2cf5\u2d02\u2d27\u2d29',
+  '\u2d29\u2d2f\u2d2f\u2d32\u2d69\u2d71\u2d71\u2d81\u2d98\u2da2\u2da8\u2daa',
+  '\u2db0\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda',
+  '\u2de0\u2de2\u2e01\u3007\u3009\u3023\u3031\u3033\u3037\u303a\u303e\u3043',
+  '\u3098\u309b\u30a1\u30a3\u30fc\u30fe\u3101\u3107\u312f\u3133\u3190\u31a2',
+  '\u31bc\u31f2\u3201\u3402\u4db7\u4e02\u9fce\ua002\ua48e\ua4d2\ua4ff\ua502',
+  '\ua60e\ua612\ua62d\ua642\ua671\ua676\ua67f\ua681\ua699\ua6a1\ua6f3\ua719',
+  '\ua721\ua724\ua78a\ua78d\ua790\ua792\ua795\ua7a2\ua7ac\ua7fa\ua829\ua842',
+  '\ua875\ua882\ua8c6\ua8d2\ua8db\ua8e2\ua8f9\ua8fd\ua8fd\ua902\ua92f\ua932',
+  '\ua955\ua962\ua97e\ua982\ua9c2\ua9d1\ua9db\uaa02\uaa38\uaa42\uaa4f\uaa52',
+  '\uaa5b\uaa62\uaa78\uaa7c\uaa7d\uaa82\uaac4\uaadd\uaadf\uaae2\uaaf1\uaaf4',
+  '\uaaf8\uab03\uab08\uab0b\uab10\uab13\uab18\uab22\uab28\uab2a\uab30\uabc2',
+  '\uabec\uabee\uabef\uabf2\uabfb\uac02\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902',
+  '\ufa6f\ufa72\ufadb\ufb02\ufb08\ufb15\ufb19\ufb1f\ufb2a\ufb2c\ufb38\ufb3a',
+  '\ufb3e\ufb40\ufb40\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52',
+  '\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe02\ufe11\ufe22\ufe28\ufe35\ufe36\ufe4f',
+  '\ufe51\ufe72\ufe76\ufe78\ufefe\uff12\uff1b\uff23\uff3c\uff41\uff41\uff43',
+  '\uff5c\uff68\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\u0003',
+  '\u0002\u001f\u001f\u0003\u0002\u001e\u001e\u0003\u0002\u000f\u000f\u0013',
+  '\u0002&&\u00a4\u00a7\u0591\u0591\u060d\u060d\u09f4\u09f5\u09fd\u09fd',
+  '\u0af3\u0af3\u0bfb\u0bfb\u0e41\u0e41\u17dd\u17dd\u20a2\u20bc\ua83a\ua83a',
+  '\ufdfe\ufdfe\ufe6b\ufe6b\uff06\uff06\uffe2\uffe3\uffe7\uffe8\u0003\u0002',
+  '""\u0003\u0002\u000b\u000b\u0003\u0002\f\f\u0003\u0002\r\r\u0003\u0002',
+  '!!\u0174\u0002C\\c|\u00ac\u00ac\u00b7\u00b7\u00bc\u00bc\u00c2\u00d8',
+  '\u00da\u00f8\u00fa\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0',
+  '\u0372\u0376\u0378\u0379\u037c\u037f\u0388\u0388\u038a\u038c\u038e\u038e',
+  '\u0390\u03a3\u03a5\u03f7\u03f9\u0483\u048c\u0529\u0533\u0558\u055b\u055b',
+  '\u0563\u0589\u05d2\u05ec\u05f2\u05f4\u0622\u064c\u0670\u0671\u0673\u06d5',
+  '\u06d7\u06d7\u06e7\u06e8\u06f0\u06f1\u06fc\u06fe\u0701\u0701\u0712\u0712',
+  '\u0714\u0731\u074f\u07a7\u07b3\u07b3\u07cc\u07ec\u07f6\u07f7\u07fc\u07fc',
+  '\u0802\u0817\u081c\u081c\u0826\u0826\u082a\u082a\u0842\u085a\u08a2\u08a2',
+  '\u08a4\u08ae\u0906\u093b\u093f\u093f\u0952\u0952\u095a\u0963\u0973\u0979',
+  '\u097b\u0981\u0987\u098e\u0991\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4',
+  '\u09b8\u09bb\u09bf\u09bf\u09d0\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3',
+  '\u0a07\u0a0c\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38',
+  '\u0a3a\u0a3b\u0a5b\u0a5e\u0a60\u0a60\u0a74\u0a76\u0a87\u0a8f\u0a91\u0a93',
+  '\u0a95\u0aaa\u0aac\u0ab2\u0ab4\u0ab5\u0ab7\u0abb\u0abf\u0abf\u0ad2\u0ad2',
+  '\u0ae2\u0ae3\u0b07\u0b0e\u0b11\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35',
+  '\u0b37\u0b3b\u0b3f\u0b3f\u0b5e\u0b5f\u0b61\u0b63\u0b73\u0b73\u0b85\u0b85',
+  '\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1',
+  '\u0ba5\u0ba6\u0baa\u0bac\u0bb0\u0bbb\u0bd2\u0bd2\u0c07\u0c0e\u0c10\u0c12',
+  '\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c3f\u0c3f\u0c5a\u0c5b\u0c62\u0c63',
+  '\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf\u0cbf',
+  '\u0ce0\u0ce0\u0ce2\u0ce3\u0cf3\u0cf4\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d3c',
+  '\u0d3f\u0d3f\u0d50\u0d50\u0d62\u0d63\u0d7c\u0d81\u0d87\u0d98\u0d9c\u0db3',
+  '\u0db5\u0dbd\u0dbf\u0dbf\u0dc2\u0dc8\u0e03\u0e32\u0e34\u0e35\u0e42\u0e48',
+  '\u0e83\u0e84\u0e86\u0e86\u0e89\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99',
+  '\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0eb2',
+  '\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2\u0ec6\u0ec8\u0ec8\u0ede\u0ee1\u0f02\u0f02',
+  '\u0f42\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002\u102c\u1041\u1041\u1052\u1057',
+  '\u105c\u105f\u1063\u1063\u1067\u1068\u1070\u1072\u1077\u1083\u1090\u1090',
+  '\u10a2\u10c7\u10c9\u10c9\u10cf\u10cf\u10d2\u10fc\u10fe\u124a\u124c\u124f',
+  '\u1252\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292\u12b2',
+  '\u12b4\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312',
+  '\u1314\u1317\u131a\u135c\u1382\u1391\u13a2\u13f6\u1403\u166e\u1671\u1681',
+  '\u1683\u169c\u16a2\u16ec\u16f0\u16f2\u1702\u170e\u1710\u1713\u1722\u1733',
+  '\u1742\u1753\u1762\u176e\u1770\u1772\u1782\u17b5\u17d9\u17d9\u17de\u17de',
+  '\u1822\u1879\u1882\u18aa\u18ac\u18ac\u18b2\u18f7\u1902\u191e\u1952\u196f',
+  '\u1972\u1976\u1982\u19ad\u19c3\u19c9\u1a02\u1a18\u1a22\u1a56\u1aa9\u1aa9',
+  '\u1b07\u1b35\u1b47\u1b4d\u1b85\u1ba2\u1bb0\u1bb1\u1bbc\u1be7\u1c02\u1c25',
+  '\u1c4f\u1c51\u1c5c\u1c7f\u1ceb\u1cee\u1cf0\u1cf3\u1cf7\u1cf8\u1d02\u1dc1',
+  '\u1e02\u1f17\u1f1a\u1f1f\u1f22\u1f47\u1f4a\u1f4f\u1f52\u1f59\u1f5b\u1f5b',
+  '\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f7f\u1f82\u1fb6\u1fb8\u1fbe\u1fc0\u1fc0',
+  '\u1fc4\u1fc6\u1fc8\u1fce\u1fd2\u1fd5\u1fd8\u1fdd\u1fe2\u1fee\u1ff4\u1ff6',
+  '\u1ff8\u1ffe\u2073\u2073\u2081\u2081\u2092\u209e\u2104\u2104\u2109\u2109',
+  '\u210c\u2115\u2117\u2117\u211a\u211f\u2126\u2126\u2128\u2128\u212a\u212a',
+  '\u212c\u213b\u213e\u2141\u2147\u214b\u2150\u2150\u2162\u218a\u2c02\u2c30',
+  '\u2c32\u2c60\u2c62\u2ce6\u2ced\u2cf0\u2cf4\u2cf5\u2d02\u2d27\u2d29\u2d29',
+  '\u2d2f\u2d2f\u2d32\u2d69\u2d71\u2d71\u2d82\u2d98\u2da2\u2da8\u2daa\u2db0',
+  '\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda\u2de0',
+  '\u3007\u3009\u3023\u302b\u3033\u3037\u303a\u303e\u3043\u3098\u309d\u30a1',
+  '\u30a3\u30fc\u30fe\u3101\u3107\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201',
+  '\u3402\u4db7\u4e02\u9fce\ua002\ua48e\ua4d2\ua4ff\ua502\ua60e\ua612\ua621',
+  '\ua62c\ua62d\ua642\ua670\ua681\ua699\ua6a2\ua6f1\ua719\ua721\ua724\ua78a',
+  '\ua78d\ua790\ua792\ua795\ua7a2\ua7ac\ua7fa\ua803\ua805\ua807\ua809\ua80c',
+  '\ua80e\ua824\ua842\ua875\ua884\ua8b5\ua8f4\ua8f9\ua8fd\ua8fd\ua90c\ua927',
+  '\ua932\ua948\ua962\ua97e\ua986\ua9b4\ua9d1\ua9d1\uaa02\uaa2a\uaa42\uaa44',
+  '\uaa46\uaa4d\uaa62\uaa78\uaa7c\uaa7c\uaa82\uaab1\uaab3\uaab3\uaab7\uaab8',
+  '\uaabb\uaabf\uaac2\uaac2\uaac4\uaac4\uaadd\uaadf\uaae2\uaaec\uaaf4\uaaf6',
+  '\uab03\uab08\uab0b\uab10\uab13\uab18\uab22\uab28\uab2a\uab30\uabc2\uabe4',
+  '\uac02\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902\ufa6f\ufa72\ufadb\ufb02\ufb08',
+  '\ufb15\ufb19\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a\ufb3e\ufb40\ufb40',
+  '\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52\ufd91\ufd94\ufdc9',
+  '\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff23\uff3c\uff43\uff5c\uff68\uffc0',
+  '\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\u0004\u0002CCcc\u0004',
+  '\u0002DDdd\u0004\u0002EEee\u0004\u0002FFff\u0004\u0002HHhh\u0004\u0002',
+  'IIii\u0004\u0002JJjj\u0004\u0002KKkk\u0004\u0002LLll\u0004\u0002MMm',
+  'm\u0004\u0002NNnn\u0004\u0002OOoo\u0004\u0002PPpp\u0004\u0002QQqq\u0004',
+  '\u0002RRrr\u0004\u0002SSss\u0004\u0002TTtt\u0004\u0002UUuu\u0004\u0002',
+  'VVvv\u0004\u0002XXxx\u0004\u0002YYyy\u0004\u0002ZZzz\u0004\u0002[[{',
+  '{\u0004\u0002\\\\||\u0002\u0517\u0002\u0003\u0003\u0002\u0002\u0002',
+  '\u0002\u0005\u0003\u0002\u0002\u0002\u0002\u0007\u0003\u0002\u0002\u0002',
+  '\u0002\t\u0003\u0002\u0002\u0002\u0002\u000b\u0003\u0002\u0002\u0002',
+  '\u0002\r\u0003\u0002\u0002\u0002\u0002\u000f\u0003\u0002\u0002\u0002',
+  '\u0002\u0011\u0003\u0002\u0002\u0002\u0002\u0013\u0003\u0002\u0002\u0002',
+  '\u0002\u0015\u0003\u0002\u0002\u0002\u0002\u0017\u0003\u0002\u0002\u0002',
+  '\u0002\u0019\u0003\u0002\u0002\u0002\u0002\u001b\u0003\u0002\u0002\u0002',
+  '\u0002\u001d\u0003\u0002\u0002\u0002\u0002\u001f\u0003\u0002\u0002\u0002',
+  '\u0002!\u0003\u0002\u0002\u0002\u0002#\u0003\u0002\u0002\u0002\u0002',
+  "%\u0003\u0002\u0002\u0002\u0002'\u0003\u0002\u0002\u0002\u0002)\u0003",
+  '\u0002\u0002\u0002\u0002+\u0003\u0002\u0002\u0002\u0002-\u0003\u0002',
+  '\u0002\u0002\u0002/\u0003\u0002\u0002\u0002\u00021\u0003\u0002\u0002',
+  '\u0002\u00023\u0003\u0002\u0002\u0002\u00025\u0003\u0002\u0002\u0002',
+  '\u00027\u0003\u0002\u0002\u0002\u00029\u0003\u0002\u0002\u0002\u0002',
+  ';\u0003\u0002\u0002\u0002\u0002=\u0003\u0002\u0002\u0002\u0002?\u0003',
+  '\u0002\u0002\u0002\u0002A\u0003\u0002\u0002\u0002\u0002C\u0003\u0002',
+  '\u0002\u0002\u0002E\u0003\u0002\u0002\u0002\u0002G\u0003\u0002\u0002',
+  '\u0002\u0002I\u0003\u0002\u0002\u0002\u0002K\u0003\u0002\u0002\u0002',
+  '\u0002M\u0003\u0002\u0002\u0002\u0002O\u0003\u0002\u0002\u0002\u0002',
+  'Q\u0003\u0002\u0002\u0002\u0002S\u0003\u0002\u0002\u0002\u0002U\u0003',
+  '\u0002\u0002\u0002\u0002W\u0003\u0002\u0002\u0002\u0002Y\u0003\u0002',
+  '\u0002\u0002\u0002[\u0003\u0002\u0002\u0002\u0002]\u0003\u0002\u0002',
+  '\u0002\u0002_\u0003\u0002\u0002\u0002\u0002a\u0003\u0002\u0002\u0002',
+  '\u0002c\u0003\u0002\u0002\u0002\u0002e\u0003\u0002\u0002\u0002\u0002',
+  'g\u0003\u0002\u0002\u0002\u0002i\u0003\u0002\u0002\u0002\u0002k\u0003',
+  '\u0002\u0002\u0002\u0002m\u0003\u0002\u0002\u0002\u0002o\u0003\u0002',
+  '\u0002\u0002\u0002q\u0003\u0002\u0002\u0002\u0002s\u0003\u0002\u0002',
+  '\u0002\u0002u\u0003\u0002\u0002\u0002\u0002w\u0003\u0002\u0002\u0002',
+  '\u0002y\u0003\u0002\u0002\u0002\u0002{\u0003\u0002\u0002\u0002\u0002',
+  '}\u0003\u0002\u0002\u0002\u0002\u007f\u0003\u0002\u0002\u0002\u0002',
+  '\u0081\u0003\u0002\u0002\u0002\u0002\u0083\u0003\u0002\u0002\u0002\u0002',
+  '\u0085\u0003\u0002\u0002\u0002\u0002\u0087\u0003\u0002\u0002\u0002\u0002',
+  '\u0089\u0003\u0002\u0002\u0002\u0002\u008b\u0003\u0002\u0002\u0002\u0002',
+  '\u008d\u0003\u0002\u0002\u0002\u0002\u008f\u0003\u0002\u0002\u0002\u0002',
+  '\u0091\u0003\u0002\u0002\u0002\u0002\u0093\u0003\u0002\u0002\u0002\u0002',
+  '\u0095\u0003\u0002\u0002\u0002\u0002\u0097\u0003\u0002\u0002\u0002\u0002',
+  '\u0099\u0003\u0002\u0002\u0002\u0002\u009b\u0003\u0002\u0002\u0002\u0002',
+  '\u009d\u0003\u0002\u0002\u0002\u0002\u009f\u0003\u0002\u0002\u0002\u0002',
+  '\u00a1\u0003\u0002\u0002\u0002\u0002\u00a3\u0003\u0002\u0002\u0002\u0002',
+  '\u00a5\u0003\u0002\u0002\u0002\u0002\u00a7\u0003\u0002\u0002\u0002\u0002',
+  '\u00a9\u0003\u0002\u0002\u0002\u0002\u00ab\u0003\u0002\u0002\u0002\u0002',
+  '\u00ad\u0003\u0002\u0002\u0002\u0002\u00af\u0003\u0002\u0002\u0002\u0002',
+  '\u00b1\u0003\u0002\u0002\u0002\u0002\u00b3\u0003\u0002\u0002\u0002\u0002',
+  '\u00b5\u0003\u0002\u0002\u0002\u0002\u00b7\u0003\u0002\u0002\u0002\u0002',
+  '\u00b9\u0003\u0002\u0002\u0002\u0002\u00bb\u0003\u0002\u0002\u0002\u0002',
+  '\u00bd\u0003\u0002\u0002\u0002\u0002\u00bf\u0003\u0002\u0002\u0002\u0002',
+  '\u00c1\u0003\u0002\u0002\u0002\u0002\u00c3\u0003\u0002\u0002\u0002\u0002',
+  '\u00c5\u0003\u0002\u0002\u0002\u0002\u00c7\u0003\u0002\u0002\u0002\u0002',
+  '\u00c9\u0003\u0002\u0002\u0002\u0002\u00cb\u0003\u0002\u0002\u0002\u0002',
+  '\u00cd\u0003\u0002\u0002\u0002\u0002\u00cf\u0003\u0002\u0002\u0002\u0002',
+  '\u00d1\u0003\u0002\u0002\u0002\u0002\u00d3\u0003\u0002\u0002\u0002\u0002',
+  '\u00d5\u0003\u0002\u0002\u0002\u0002\u00d7\u0003\u0002\u0002\u0002\u0002',
+  '\u00d9\u0003\u0002\u0002\u0002\u0002\u00db\u0003\u0002\u0002\u0002\u0002',
+  '\u00dd\u0003\u0002\u0002\u0002\u0002\u00df\u0003\u0002\u0002\u0002\u0002',
+  '\u00e1\u0003\u0002\u0002\u0002\u0002\u00e3\u0003\u0002\u0002\u0002\u0002',
+  '\u00e5\u0003\u0002\u0002\u0002\u0002\u00e7\u0003\u0002\u0002\u0002\u0002',
+  '\u00e9\u0003\u0002\u0002\u0002\u0002\u00eb\u0003\u0002\u0002\u0002\u0002',
+  '\u00ed\u0003\u0002\u0002\u0002\u0002\u00ef\u0003\u0002\u0002\u0002\u0002',
+  '\u00f1\u0003\u0002\u0002\u0002\u0002\u00f3\u0003\u0002\u0002\u0002\u0002',
+  '\u00f5\u0003\u0002\u0002\u0002\u0002\u00f7\u0003\u0002\u0002\u0002\u0002',
+  '\u00f9\u0003\u0002\u0002\u0002\u0002\u00fb\u0003\u0002\u0002\u0002\u0002',
+  '\u00fd\u0003\u0002\u0002\u0002\u0002\u00ff\u0003\u0002\u0002\u0002\u0002',
+  '\u0101\u0003\u0002\u0002\u0002\u0002\u0103\u0003\u0002\u0002\u0002\u0002',
+  '\u0105\u0003\u0002\u0002\u0002\u0002\u0107\u0003\u0002\u0002\u0002\u0002',
+  '\u0109\u0003\u0002\u0002\u0002\u0002\u010b\u0003\u0002\u0002\u0002\u0002',
+  '\u010d\u0003\u0002\u0002\u0002\u0002\u010f\u0003\u0002\u0002\u0002\u0002',
+  '\u0111\u0003\u0002\u0002\u0002\u0002\u0113\u0003\u0002\u0002\u0002\u0002',
+  '\u0115\u0003\u0002\u0002\u0002\u0002\u0117\u0003\u0002\u0002\u0002\u0002',
+  '\u0119\u0003\u0002\u0002\u0002\u0002\u011b\u0003\u0002\u0002\u0002\u0002',
+  '\u011d\u0003\u0002\u0002\u0002\u0002\u011f\u0003\u0002\u0002\u0002\u0002',
+  '\u0121\u0003\u0002\u0002\u0002\u0002\u0123\u0003\u0002\u0002\u0002\u0002',
+  '\u0125\u0003\u0002\u0002\u0002\u0002\u0127\u0003\u0002\u0002\u0002\u0002',
+  '\u0129\u0003\u0002\u0002\u0002\u0002\u012b\u0003\u0002\u0002\u0002\u0002',
+  '\u012d\u0003\u0002\u0002\u0002\u0002\u012f\u0003\u0002\u0002\u0002\u0002',
+  '\u0131\u0003\u0002\u0002\u0002\u0002\u0133\u0003\u0002\u0002\u0002\u0002',
+  '\u0135\u0003\u0002\u0002\u0002\u0003\u0185\u0003\u0002\u0002\u0002\u0005',
+  '\u0187\u0003\u0002\u0002\u0002\u0007\u0189\u0003\u0002\u0002\u0002\t',
+  '\u018b\u0003\u0002\u0002\u0002\u000b\u018e\u0003\u0002\u0002\u0002\r',
+  '\u0192\u0003\u0002\u0002\u0002\u000f\u0194\u0003\u0002\u0002\u0002\u0011',
+  '\u0196\u0003\u0002\u0002\u0002\u0013\u0198\u0003\u0002\u0002\u0002\u0015',
+  '\u019a\u0003\u0002\u0002\u0002\u0017\u019c\u0003\u0002\u0002\u0002\u0019',
+  '\u019e\u0003\u0002\u0002\u0002\u001b\u01a0\u0003\u0002\u0002\u0002\u001d',
+  '\u01a2\u0003\u0002\u0002\u0002\u001f\u01a4\u0003\u0002\u0002\u0002!',
+  '\u01a6\u0003\u0002\u0002\u0002#\u01a8\u0003\u0002\u0002\u0002%\u01aa',
+  "\u0003\u0002\u0002\u0002'\u01ac\u0003\u0002\u0002\u0002)\u01ae\u0003",
+  '\u0002\u0002\u0002+\u01b0\u0003\u0002\u0002\u0002-\u01b3\u0003\u0002',
+  '\u0002\u0002/\u01b5\u0003\u0002\u0002\u00021\u01b7\u0003\u0002\u0002',
+  '\u00023\u01ba\u0003\u0002\u0002\u00025\u01bc\u0003\u0002\u0002\u0002',
+  '7\u01be\u0003\u0002\u0002\u00029\u01c1\u0003\u0002\u0002\u0002;\u01c4',
+  '\u0003\u0002\u0002\u0002=\u01c7\u0003\u0002\u0002\u0002?\u01c9\u0003',
+  '\u0002\u0002\u0002A\u01cb\u0003\u0002\u0002\u0002C\u01ce\u0003\u0002',
+  '\u0002\u0002E\u01d1\u0003\u0002\u0002\u0002G\u01d3\u0003\u0002\u0002',
+  '\u0002I\u01d5\u0003\u0002\u0002\u0002K\u01d7\u0003\u0002\u0002\u0002',
+  'M\u01d9\u0003\u0002\u0002\u0002O\u01db\u0003\u0002\u0002\u0002Q\u01dd',
+  '\u0003\u0002\u0002\u0002S\u01df\u0003\u0002\u0002\u0002U\u01e1\u0003',
+  '\u0002\u0002\u0002W\u01e3\u0003\u0002\u0002\u0002Y\u01e5\u0003\u0002',
+  '\u0002\u0002[\u01e7\u0003\u0002\u0002\u0002]\u01e9\u0003\u0002\u0002',
+  '\u0002_\u01eb\u0003\u0002\u0002\u0002a\u01ed\u0003\u0002\u0002\u0002',
+  'c\u01ef\u0003\u0002\u0002\u0002e\u01f1\u0003\u0002\u0002\u0002g\u01f3',
+  '\u0003\u0002\u0002\u0002i\u01f5\u0003\u0002\u0002\u0002k\u01f7\u0003',
+  '\u0002\u0002\u0002m\u01f9\u0003\u0002\u0002\u0002o\u0200\u0003\u0002',
+  '\u0002\u0002q\u0208\u0003\u0002\u0002\u0002s\u0210\u0003\u0002\u0002',
+  '\u0002u\u0216\u0003\u0002\u0002\u0002w\u021f\u0003\u0002\u0002\u0002',
+  'y\u0226\u0003\u0002\u0002\u0002{\u022c\u0003\u0002\u0002\u0002}\u0230',
+  '\u0003\u0002\u0002\u0002\u007f\u0237\u0003\u0002\u0002\u0002\u0081\u023c',
+  '\u0003\u0002\u0002\u0002\u0083\u0242\u0003\u0002\u0002\u0002\u0085\u0245',
+  '\u0003\u0002\u0002\u0002\u0087\u0250\u0003\u0002\u0002\u0002\u0089\u0257',
+  '\u0003\u0002\u0002\u0002\u008b\u025a\u0003\u0002\u0002\u0002\u008d\u0261',
+  '\u0003\u0002\u0002\u0002\u008f\u0268\u0003\u0002\u0002\u0002\u0091\u026d',
+  '\u0003\u0002\u0002\u0002\u0093\u0271\u0003\u0002\u0002\u0002\u0095\u0276',
+  '\u0003\u0002\u0002\u0002\u0097\u027e\u0003\u0002\u0002\u0002\u0099\u0283',
+  '\u0003\u0002\u0002\u0002\u009b\u0286\u0003\u0002\u0002\u0002\u009d\u0296',
+  '\u0003\u0002\u0002\u0002\u009f\u029f\u0003\u0002\u0002\u0002\u00a1\u02a5',
+  '\u0003\u0002\u0002\u0002\u00a3\u02ac\u0003\u0002\u0002\u0002\u00a5\u02b2',
+  '\u0003\u0002\u0002\u0002\u00a7\u02b6\u0003\u0002\u0002\u0002\u00a9\u02bd',
+  '\u0003\u0002\u0002\u0002\u00ab\u02c4\u0003\u0002\u0002\u0002\u00ad\u02cb',
+  '\u0003\u0002\u0002\u0002\u00af\u02d3\u0003\u0002\u0002\u0002\u00b1\u02d6',
+  '\u0003\u0002\u0002\u0002\u00b3\u02df\u0003\u0002\u0002\u0002\u00b5\u02e6',
+  '\u0003\u0002\u0002\u0002\u00b7\u02ec\u0003\u0002\u0002\u0002\u00b9\u02ef',
+  '\u0003\u0002\u0002\u0002\u00bb\u02f4\u0003\u0002\u0002\u0002\u00bd\u02fa',
+  '\u0003\u0002\u0002\u0002\u00bf\u0304\u0003\u0002\u0002\u0002\u00c1\u0308',
+  '\u0003\u0002\u0002\u0002\u00c3\u0313\u0003\u0002\u0002\u0002\u00c5\u0318',
+  '\u0003\u0002\u0002\u0002\u00c7\u031d\u0003\u0002\u0002\u0002\u00c9\u0322',
+  '\u0003\u0002\u0002\u0002\u00cb\u0328\u0003\u0002\u0002\u0002\u00cd\u032d',
+  '\u0003\u0002\u0002\u0002\u00cf\u033a\u0003\u0002\u0002\u0002\u00d1\u033e',
+  '\u0003\u0002\u0002\u0002\u00d3\u0344\u0003\u0002\u0002\u0002\u00d5\u0351',
+  '\u0003\u0002\u0002\u0002\u00d7\u0362\u0003\u0002\u0002\u0002\u00d9\u0365',
+  '\u0003\u0002\u0002\u0002\u00db\u0369\u0003\u0002\u0002\u0002\u00dd\u036d',
+  '\u0003\u0002\u0002\u0002\u00df\u0371\u0003\u0002\u0002\u0002\u00e1\u0378',
+  '\u0003\u0002\u0002\u0002\u00e3\u037d\u0003\u0002\u0002\u0002\u00e5\u0386',
+  '\u0003\u0002\u0002\u0002\u00e7\u038b\u0003\u0002\u0002\u0002\u00e9\u0391',
+  '\u0003\u0002\u0002\u0002\u00eb\u0398\u0003\u0002\u0002\u0002\u00ed\u03a0',
+  '\u0003\u0002\u0002\u0002\u00ef\u03a4\u0003\u0002\u0002\u0002\u00f1\u03a9',
+  '\u0003\u0002\u0002\u0002\u00f3\u03b0\u0003\u0002\u0002\u0002\u00f5\u03b5',
+  '\u0003\u0002\u0002\u0002\u00f7\u03bb\u0003\u0002\u0002\u0002\u00f9\u03c2',
+  '\u0003\u0002\u0002\u0002\u00fb\u03c7\u0003\u0002\u0002\u0002\u00fd\u03cc',
+  '\u0003\u0002\u0002\u0002\u00ff\u03d0\u0003\u0002\u0002\u0002\u0101\u03d5',
+  '\u0003\u0002\u0002\u0002\u0103\u03da\u0003\u0002\u0002\u0002\u0105\u03df',
+  '\u0003\u0002\u0002\u0002\u0107\u03e5\u0003\u0002\u0002\u0002\u0109\u0403',
+  '\u0003\u0002\u0002\u0002\u010b\u0408\u0003\u0002\u0002\u0002\u010d\u040c',
+  '\u0003\u0002\u0002\u0002\u010f\u0420\u0003\u0002\u0002\u0002\u0111\u0430',
+  '\u0003\u0002\u0002\u0002\u0113\u0432\u0003\u0002\u0002\u0002\u0115\u0439',
+  '\u0003\u0002\u0002\u0002\u0117\u043d\u0003\u0002\u0002\u0002\u0119\u0441',
+  '\u0003\u0002\u0002\u0002\u011b\u0445\u0003\u0002\u0002\u0002\u011d\u0447',
+  '\u0003\u0002\u0002\u0002\u011f\u044b\u0003\u0002\u0002\u0002\u0121\u044d',
+  '\u0003\u0002\u0002\u0002\u0123\u0465\u0003\u0002\u0002\u0002\u0125\u0473',
+  '\u0003\u0002\u0002\u0002\u0127\u047c\u0003\u0002\u0002\u0002\u0129\u0485',
+  '\u0003\u0002\u0002\u0002\u012b\u0489\u0003\u0002\u0002\u0002\u012d\u048b',
+  '\u0003\u0002\u0002\u0002\u012f\u0497\u0003\u0002\u0002\u0002\u0131\u04a7',
+  '\u0003\u0002\u0002\u0002\u0133\u04bd\u0003\u0002\u0002\u0002\u0135\u04bf',
+  '\u0003\u0002\u0002\u0002\u0137\u04c1\u0003\u0002\u0002\u0002\u0139\u04c3',
+  '\u0003\u0002\u0002\u0002\u013b\u04c5\u0003\u0002\u0002\u0002\u013d\u04c7',
+  '\u0003\u0002\u0002\u0002\u013f\u04c9\u0003\u0002\u0002\u0002\u0141\u04cb',
+  '\u0003\u0002\u0002\u0002\u0143\u04cd\u0003\u0002\u0002\u0002\u0145\u04cf',
+  '\u0003\u0002\u0002\u0002\u0147\u04d1\u0003\u0002\u0002\u0002\u0149\u04d3',
+  '\u0003\u0002\u0002\u0002\u014b\u04d5\u0003\u0002\u0002\u0002\u014d\u04d7',
+  '\u0003\u0002\u0002\u0002\u014f\u04d9\u0003\u0002\u0002\u0002\u0151\u04db',
+  '\u0003\u0002\u0002\u0002\u0153\u04dd\u0003\u0002\u0002\u0002\u0155\u04df',
+  '\u0003\u0002\u0002\u0002\u0157\u04e1\u0003\u0002\u0002\u0002\u0159\u04e3',
+  '\u0003\u0002\u0002\u0002\u015b\u04e5\u0003\u0002\u0002\u0002\u015d\u04e7',
+  '\u0003\u0002\u0002\u0002\u015f\u04e9\u0003\u0002\u0002\u0002\u0161\u04eb',
+  '\u0003\u0002\u0002\u0002\u0163\u04ed\u0003\u0002\u0002\u0002\u0165\u04ef',
+  '\u0003\u0002\u0002\u0002\u0167\u04f1\u0003\u0002\u0002\u0002\u0169\u04f3',
+  '\u0003\u0002\u0002\u0002\u016b\u04f5\u0003\u0002\u0002\u0002\u016d\u04f7',
+  '\u0003\u0002\u0002\u0002\u016f\u04f9\u0003\u0002\u0002\u0002\u0171\u04fb',
+  '\u0003\u0002\u0002\u0002\u0173\u04fd\u0003\u0002\u0002\u0002\u0175\u04ff',
+  '\u0003\u0002\u0002\u0002\u0177\u0501\u0003\u0002\u0002\u0002\u0179\u0503',
+  '\u0003\u0002\u0002\u0002\u017b\u0505\u0003\u0002\u0002\u0002\u017d\u0507',
+  '\u0003\u0002\u0002\u0002\u017f\u0509\u0003\u0002\u0002\u0002\u0181\u050b',
+  '\u0003\u0002\u0002\u0002\u0183\u050d\u0003\u0002\u0002\u0002\u0185\u0186',
+  '\u0007=\u0002\u0002\u0186\u0004\u0003\u0002\u0002\u0002\u0187\u0188',
+  '\u0007<\u0002\u0002\u0188\u0006\u0003\u0002\u0002\u0002\u0189\u018a',
+  '\u0007/\u0002\u0002\u018a\b\u0003\u0002\u0002\u0002\u018b\u018c\u0007',
+  '?\u0002\u0002\u018c\u018d\u0007@\u0002\u0002\u018d\n\u0003\u0002\u0002',
+  '\u0002\u018e\u018f\u0007<\u0002\u0002\u018f\u0190\u00071\u0002\u0002',
+  '\u0190\u0191\u00071\u0002\u0002\u0191\f\u0003\u0002\u0002\u0002\u0192',
+  '\u0193\u00071\u0002\u0002\u0193\u000e\u0003\u0002\u0002\u0002\u0194',
+  '\u0195\u00070\u0002\u0002\u0195\u0010\u0003\u0002\u0002\u0002\u0196',
+  '\u0197\u0007B\u0002\u0002\u0197\u0012\u0003\u0002\u0002\u0002\u0198',
+  '\u0199\u0007%\u0002\u0002\u0199\u0014\u0003\u0002\u0002\u0002\u019a',
+  '\u019b\u0007A\u0002\u0002\u019b\u0016\u0003\u0002\u0002\u0002\u019c',
+  '\u019d\u0007(\u0002\u0002\u019d\u0018\u0003\u0002\u0002\u0002\u019e',
+  '\u019f\u0007?\u0002\u0002\u019f\u001a\u0003\u0002\u0002\u0002\u01a0',
+  '\u01a1\u0007-\u0002\u0002\u01a1\u001c\u0003\u0002\u0002\u0002\u01a2',
+  '\u01a3\u0007}\u0002\u0002\u01a3\u001e\u0003\u0002\u0002\u0002\u01a4',
+  '\u01a5\u0007.\u0002\u0002\u01a5 \u0003\u0002\u0002\u0002\u01a6\u01a7',
+  '\u0007\u007f\u0002\u0002\u01a7"\u0003\u0002\u0002\u0002\u01a8\u01a9',
+  '\u0007]\u0002\u0002\u01a9$\u0003\u0002\u0002\u0002\u01aa\u01ab\u0007',
+  '_\u0002\u0002\u01ab&\u0003\u0002\u0002\u0002\u01ac\u01ad\u0007*\u0002',
+  '\u0002\u01ad(\u0003\u0002\u0002\u0002\u01ae\u01af\u0007+\u0002\u0002',
+  '\u01af*\u0003\u0002\u0002\u0002\u01b0\u01b1\u0007-\u0002\u0002\u01b1',
+  '\u01b2\u0007?\u0002\u0002\u01b2,\u0003\u0002\u0002\u0002\u01b3\u01b4',
+  '\u0007~\u0002\u0002\u01b4.\u0003\u0002\u0002\u0002\u01b5\u01b6\u0007',
+  ',\u0002\u0002\u01b60\u0003\u0002\u0002\u0002\u01b7\u01b8\u00070\u0002',
+  '\u0002\u01b8\u01b9\u00070\u0002\u0002\u01b92\u0003\u0002\u0002\u0002',
+  "\u01ba\u01bb\u0007'\u0002\u0002\u01bb4\u0003\u0002\u0002\u0002\u01bc",
+  '\u01bd\u0007`\u0002\u0002\u01bd6\u0003\u0002\u0002\u0002\u01be\u01bf',
+  '\u0007?\u0002\u0002\u01bf\u01c0\u0007\u0080\u0002\u0002\u01c08\u0003',
+  '\u0002\u0002\u0002\u01c1\u01c2\u0007>\u0002\u0002\u01c2\u01c3\u0007',
+  '@\u0002\u0002\u01c3:\u0003\u0002\u0002\u0002\u01c4\u01c5\u0007#\u0002',
+  '\u0002\u01c5\u01c6\u0007?\u0002\u0002\u01c6<\u0003\u0002\u0002\u0002',
+  '\u01c7\u01c8\u0007>\u0002\u0002\u01c8>\u0003\u0002\u0002\u0002\u01c9',
+  '\u01ca\u0007@\u0002\u0002\u01ca@\u0003\u0002\u0002\u0002\u01cb\u01cc',
+  '\u0007>\u0002\u0002\u01cc\u01cd\u0007?\u0002\u0002\u01cdB\u0003\u0002',
+  '\u0002\u0002\u01ce\u01cf\u0007@\u0002\u0002\u01cf\u01d0\u0007?\u0002',
+  '\u0002\u01d0D\u0003\u0002\u0002\u0002\u01d1\u01d2\u0007&\u0002\u0002',
+  '\u01d2F\u0003\u0002\u0002\u0002\u01d3\u01d4\u0007\u27ea\u0002\u0002',
+  '\u01d4H\u0003\u0002\u0002\u0002\u01d5\u01d6\u0007\u300a\u0002\u0002',
+  '\u01d6J\u0003\u0002\u0002\u0002\u01d7\u01d8\u0007\ufe66\u0002\u0002',
+  '\u01d8L\u0003\u0002\u0002\u0002\u01d9\u01da\u0007\uff1e\u0002\u0002',
+  '\u01daN\u0003\u0002\u0002\u0002\u01db\u01dc\u0007\u27eb\u0002\u0002',
+  '\u01dcP\u0003\u0002\u0002\u0002\u01dd\u01de\u0007\u300b\u0002\u0002',
+  '\u01deR\u0003\u0002\u0002\u0002\u01df\u01e0\u0007\ufe67\u0002\u0002',
+  '\u01e0T\u0003\u0002\u0002\u0002\u01e1\u01e2\u0007\uff20\u0002\u0002',
+  '\u01e2V\u0003\u0002\u0002\u0002\u01e3\u01e4\u0007\u00af\u0002\u0002',
+  '\u01e4X\u0003\u0002\u0002\u0002\u01e5\u01e6\u0007\u2012\u0002\u0002',
+  '\u01e6Z\u0003\u0002\u0002\u0002\u01e7\u01e8\u0007\u2013\u0002\u0002',
+  '\u01e8\\\u0003\u0002\u0002\u0002\u01e9\u01ea\u0007\u2014\u0002\u0002',
+  '\u01ea^\u0003\u0002\u0002\u0002\u01eb\u01ec\u0007\u2015\u0002\u0002',
+  '\u01ec`\u0003\u0002\u0002\u0002\u01ed\u01ee\u0007\u2016\u0002\u0002',
+  '\u01eeb\u0003\u0002\u0002\u0002\u01ef\u01f0\u0007\u2017\u0002\u0002',
+  '\u01f0d\u0003\u0002\u0002\u0002\u01f1\u01f2\u0007\u2214\u0002\u0002',
+  '\u01f2f\u0003\u0002\u0002\u0002\u01f3\u01f4\u0007\ufe5a\u0002\u0002',
+  '\u01f4h\u0003\u0002\u0002\u0002\u01f5\u01f6\u0007\ufe65\u0002\u0002',
+  '\u01f6j\u0003\u0002\u0002\u0002\u01f7\u01f8\u0007\uff0f\u0002\u0002',
+  '\u01f8l\u0003\u0002\u0002\u0002\u01f9\u01fa\u0005\u0155\u00ab\u0002',
+  '\u01fa\u01fb\u0005\u0181\u00c1\u0002\u01fb\u01fc\u0005\u016f\u00b8\u0002',
+  '\u01fc\u01fd\u0005\u015f\u00b0\u0002\u01fd\u01fe\u0005\u0159\u00ad\u0002',
+  '\u01fe\u01ff\u0005\u0173\u00ba\u0002\u01ffn\u0003\u0002\u0002\u0002',
+  '\u0200\u0201\u0005\u0159\u00ad\u0002\u0201\u0202\u0005\u017f\u00c0\u0002',
+  '\u0202\u0203\u0005\u016f\u00b8\u0002\u0203\u0204\u0005\u0167\u00b4\u0002',
+  '\u0204\u0205\u0005\u0151\u00a9\u0002\u0205\u0206\u0005\u0161\u00b1\u0002',
+  '\u0206\u0207\u0005\u016b\u00b6\u0002\u0207p\u0003\u0002\u0002\u0002',
+  '\u0208\u0209\u0005\u016f\u00b8\u0002\u0209\u020a\u0005\u0173\u00ba\u0002',
+  '\u020a\u020b\u0005\u016d\u00b7\u0002\u020b\u020c\u0005\u015b\u00ae\u0002',
+  '\u020c\u020d\u0005\u0161\u00b1\u0002\u020d\u020e\u0005\u0167\u00b4\u0002',
+  '\u020e\u020f\u0005\u0159\u00ad\u0002\u020fr\u0003\u0002\u0002\u0002',
+  '\u0210\u0211\u0005\u0179\u00bd\u0002\u0211\u0212\u0005\u0175\u00bb\u0002',
+  '\u0212\u0213\u0005\u0161\u00b1\u0002\u0213\u0214\u0005\u016b\u00b6\u0002',
+  '\u0214\u0215\u0005\u015d\u00af\u0002\u0215t\u0003\u0002\u0002\u0002',
+  '\u0216\u0217\u0005\u016f\u00b8\u0002\u0217\u0218\u0005\u0159\u00ad\u0002',
+  '\u0218\u0219\u0005\u0173\u00ba\u0002\u0219\u021a\u0005\u0161\u00b1\u0002',
+  '\u021a\u021b\u0005\u016d\u00b7\u0002\u021b\u021c\u0005\u0157\u00ac\u0002',
+  '\u021c\u021d\u0005\u0161\u00b1\u0002\u021d\u021e\u0005\u0155\u00ab\u0002',
+  '\u021ev\u0003\u0002\u0002\u0002\u021f\u0220\u0005\u0155\u00ab\u0002',
+  '\u0220\u0221\u0005\u016d\u00b7\u0002\u0221\u0222\u0005\u0169\u00b5\u0002',
+  '\u0222\u0223\u0005\u0169\u00b5\u0002\u0223\u0224\u0005\u0161\u00b1\u0002',
+  '\u0224\u0225\u0005\u0177\u00bc\u0002\u0225x\u0003\u0002\u0002\u0002',
+  '\u0226\u0227\u0005\u0179\u00bd\u0002\u0227\u0228\u0005\u016b\u00b6\u0002',
+  '\u0228\u0229\u0005\u0161\u00b1\u0002\u0229\u022a\u0005\u016d\u00b7\u0002',
+  '\u022a\u022b\u0005\u016b\u00b6\u0002\u022bz\u0003\u0002\u0002\u0002',
+  '\u022c\u022d\u0005\u0151\u00a9\u0002\u022d\u022e\u0005\u0167\u00b4\u0002',
+  '\u022e\u022f\u0005\u0167\u00b4\u0002\u022f|\u0003\u0002\u0002\u0002',
+  '\u0230\u0231\u0005\u0155\u00ab\u0002\u0231\u0232\u0005\u0173\u00ba\u0002',
+  '\u0232\u0233\u0005\u0159\u00ad\u0002\u0233\u0234\u0005\u0151\u00a9\u0002',
+  '\u0234\u0235\u0005\u0177\u00bc\u0002\u0235\u0236\u0005\u0159\u00ad\u0002',
+  '\u0236~\u0003\u0002\u0002\u0002\u0237\u0238\u0005\u0157\u00ac\u0002',
+  '\u0238\u0239\u0005\u0173\u00ba\u0002\u0239\u023a\u0005\u016d\u00b7\u0002',
+  '\u023a\u023b\u0005\u016f\u00b8\u0002\u023b\u0080\u0003\u0002\u0002\u0002',
+  '\u023c\u023d\u0005\u0161\u00b1\u0002\u023d\u023e\u0005\u016b\u00b6\u0002',
+  '\u023e\u023f\u0005\u0157\u00ac\u0002\u023f\u0240\u0005\u0159\u00ad\u0002',
+  '\u0240\u0241\u0005\u017f\u00c0\u0002\u0241\u0082\u0003\u0002\u0002\u0002',
+  '\u0242\u0243\u0005\u016d\u00b7\u0002\u0243\u0244\u0005\u016b\u00b6\u0002',
+  '\u0244\u0084\u0003\u0002\u0002\u0002\u0245\u0246\u0005\u0155\u00ab\u0002',
+  '\u0246\u0247\u0005\u016d\u00b7\u0002\u0247\u0248\u0005\u016b\u00b6\u0002',
+  '\u0248\u0249\u0005\u0175\u00bb\u0002\u0249\u024a\u0005\u0177\u00bc\u0002',
+  '\u024a\u024b\u0005\u0173\u00ba\u0002\u024b\u024c\u0005\u0151\u00a9\u0002',
+  '\u024c\u024d\u0005\u0161\u00b1\u0002\u024d\u024e\u0005\u016b\u00b6\u0002',
+  '\u024e\u024f\u0005\u0177\u00bc\u0002\u024f\u0086\u0003\u0002\u0002\u0002',
+  '\u0250\u0251\u0005\u0151\u00a9\u0002\u0251\u0252\u0005\u0175\u00bb\u0002',
+  '\u0252\u0253\u0005\u0175\u00bb\u0002\u0253\u0254\u0005\u0159\u00ad\u0002',
+  '\u0254\u0255\u0005\u0173\u00ba\u0002\u0255\u0256\u0005\u0177\u00bc\u0002',
+  '\u0256\u0088\u0003\u0002\u0002\u0002\u0257\u0258\u0005\u0161\u00b1\u0002',
+  '\u0258\u0259\u0005\u0175\u00bb\u0002\u0259\u008a\u0003\u0002\u0002\u0002',
+  '\u025a\u025b\u0005\u0179\u00bd\u0002\u025b\u025c\u0005\u016b\u00b6\u0002',
+  '\u025c\u025d\u0005\u0161\u00b1\u0002\u025d\u025e\u0005\u0171\u00b9\u0002',
+  '\u025e\u025f\u0005\u0179\u00bd\u0002\u025f\u0260\u0005\u0159\u00ad\u0002',
+  '\u0260\u008c\u0003\u0002\u0002\u0002\u0261\u0262\u0005\u0159\u00ad\u0002',
+  '\u0262\u0263\u0005\u017f\u00c0\u0002\u0263\u0264\u0005\u0161\u00b1\u0002',
+  '\u0264\u0265\u0005\u0175\u00bb\u0002\u0265\u0266\u0005\u0177\u00bc\u0002',
+  '\u0266\u0267\u0005\u0175\u00bb\u0002\u0267\u008e\u0003\u0002\u0002\u0002',
+  '\u0268\u0269\u0005\u0167\u00b4\u0002\u0269\u026a\u0005\u016d\u00b7\u0002',
+  '\u026a\u026b\u0005\u0151\u00a9\u0002\u026b\u026c\u0005\u0157\u00ac\u0002',
+  '\u026c\u0090\u0003\u0002\u0002\u0002\u026d\u026e\u0005\u0155\u00ab\u0002',
+  '\u026e\u026f\u0005\u0175\u00bb\u0002\u026f\u0270\u0005\u017b\u00be\u0002',
+  '\u0270\u0092\u0003\u0002\u0002\u0002\u0271\u0272\u0005\u017d\u00bf\u0002',
+  '\u0272\u0273\u0005\u0161\u00b1\u0002\u0273\u0274\u0005\u0177\u00bc\u0002',
+  '\u0274\u0275\u0005\u015f\u00b0\u0002\u0275\u0094\u0003\u0002\u0002\u0002',
+  '\u0276\u0277\u0005\u015f\u00b0\u0002\u0277\u0278\u0005\u0159\u00ad\u0002',
+  '\u0278\u0279\u0005\u0151\u00a9\u0002\u0279\u027a\u0005\u0157\u00ac\u0002',
+  '\u027a\u027b\u0005\u0159\u00ad\u0002\u027b\u027c\u0005\u0173\u00ba\u0002',
+  '\u027c\u027d\u0005\u0175\u00bb\u0002\u027d\u0096\u0003\u0002\u0002\u0002',
+  '\u027e\u027f\u0005\u015b\u00ae\u0002\u027f\u0280\u0005\u0173\u00ba\u0002',
+  '\u0280\u0281\u0005\u016d\u00b7\u0002\u0281\u0282\u0005\u0169\u00b5\u0002',
+  '\u0282\u0098\u0003\u0002\u0002\u0002\u0283\u0284\u0005\u0151\u00a9\u0002',
+  '\u0284\u0285\u0005\u0175\u00bb\u0002\u0285\u009a\u0003\u0002\u0002\u0002',
+  '\u0286\u0287\u0005\u015b\u00ae\u0002\u0287\u0288\u0005\u0161\u00b1\u0002',
+  '\u0288\u0289\u0005\u0159\u00ad\u0002\u0289\u028a\u0005\u0167\u00b4\u0002',
+  '\u028a\u028b\u0005\u0157\u00ac\u0002\u028b\u028c\u0005\u0177\u00bc\u0002',
+  '\u028c\u028d\u0005\u0159\u00ad\u0002\u028d\u028e\u0005\u0173\u00ba\u0002',
+  '\u028e\u028f\u0005\u0169\u00b5\u0002\u028f\u0290\u0005\u0161\u00b1\u0002',
+  '\u0290\u0291\u0005\u016b\u00b6\u0002\u0291\u0292\u0005\u0151\u00a9\u0002',
+  '\u0292\u0293\u0005\u0177\u00bc\u0002\u0293\u0294\u0005\u016d\u00b7\u0002',
+  '\u0294\u0295\u0005\u0173\u00ba\u0002\u0295\u009c\u0003\u0002\u0002\u0002',
+  '\u0296\u0297\u0005\u016d\u00b7\u0002\u0297\u0298\u0005\u016f\u00b8\u0002',
+  '\u0298\u0299\u0005\u0177\u00bc\u0002\u0299\u029a\u0005\u0161\u00b1\u0002',
+  '\u029a\u029b\u0005\u016d\u00b7\u0002\u029b\u029c\u0005\u016b\u00b6\u0002',
+  '\u029c\u029d\u0005\u0151\u00a9\u0002\u029d\u029e\u0005\u0167\u00b4\u0002',
+  '\u029e\u009e\u0003\u0002\u0002\u0002\u029f\u02a0\u0005\u0169\u00b5\u0002',
+  '\u02a0\u02a1\u0005\u0151\u00a9\u0002\u02a1\u02a2\u0005\u0177\u00bc\u0002',
+  '\u02a2\u02a3\u0005\u0155\u00ab\u0002\u02a3\u02a4\u0005\u015f\u00b0\u0002',
+  '\u02a4\u00a0\u0003\u0002\u0002\u0002\u02a5\u02a6\u0005\u0179\u00bd\u0002',
+  '\u02a6\u02a7\u0005\u016b\u00b6\u0002\u02a7\u02a8\u0005\u017d\u00bf\u0002',
+  '\u02a8\u02a9\u0005\u0161\u00b1\u0002\u02a9\u02aa\u0005\u016b\u00b6\u0002',
+  '\u02aa\u02ab\u0005\u0157\u00ac\u0002\u02ab\u00a2\u0003\u0002\u0002\u0002',
+  '\u02ac\u02ad\u0005\u0169\u00b5\u0002\u02ad\u02ae\u0005\u0159\u00ad\u0002',
+  '\u02ae\u02af\u0005\u0173\u00ba\u0002\u02af\u02b0\u0005\u015d\u00af\u0002',
+  '\u02b0\u02b1\u0005\u0159\u00ad\u0002\u02b1\u00a4\u0003\u0002\u0002\u0002',
+  '\u02b2\u02b3\u0005\u0175\u00bb\u0002\u02b3\u02b4\u0005\u0159\u00ad\u0002',
+  '\u02b4\u02b5\u0005\u0177\u00bc\u0002\u02b5\u00a6\u0003\u0002\u0002\u0002',
+  '\u02b6\u02b7\u0005\u0157\u00ac\u0002\u02b7\u02b8\u0005\u0159\u00ad\u0002',
+  '\u02b8\u02b9\u0005\u0177\u00bc\u0002\u02b9\u02ba\u0005\u0151\u00a9\u0002',
+  '\u02ba\u02bb\u0005\u0155\u00ab\u0002\u02bb\u02bc\u0005\u015f\u00b0\u0002',
+  '\u02bc\u00a8\u0003\u0002\u0002\u0002\u02bd\u02be\u0005\u0157\u00ac\u0002',
+  '\u02be\u02bf\u0005\u0159\u00ad\u0002\u02bf\u02c0\u0005\u0167\u00b4\u0002',
+  '\u02c0\u02c1\u0005\u0159\u00ad\u0002\u02c1\u02c2\u0005\u0177\u00bc\u0002',
+  '\u02c2\u02c3\u0005\u0159\u00ad\u0002\u02c3\u00aa\u0003\u0002\u0002\u0002',
+  '\u02c4\u02c5\u0005\u0173\u00ba\u0002\u02c5\u02c6\u0005\u0159\u00ad\u0002',
+  '\u02c6\u02c7\u0005\u0169\u00b5\u0002\u02c7\u02c8\u0005\u016d\u00b7\u0002',
+  '\u02c8\u02c9\u0005\u017b\u00be\u0002\u02c9\u02ca\u0005\u0159\u00ad\u0002',
+  '\u02ca\u00ac\u0003\u0002\u0002\u0002\u02cb\u02cc\u0005\u015b\u00ae\u0002',
+  '\u02cc\u02cd\u0005\u016d\u00b7\u0002\u02cd\u02ce\u0005\u0173\u00ba\u0002',
+  '\u02ce\u02cf\u0005\u0159\u00ad\u0002\u02cf\u02d0\u0005\u0151\u00a9\u0002',
+  '\u02d0\u02d1\u0005\u0155\u00ab\u0002\u02d1\u02d2\u0005\u015f\u00b0\u0002',
+  '\u02d2\u00ae\u0003\u0002\u0002\u0002\u02d3\u02d4\u0005\u0161\u00b1\u0002',
+  '\u02d4\u02d5\u0005\u016b\u00b6\u0002\u02d5\u00b0\u0003\u0002\u0002\u0002',
+  '\u02d6\u02d7\u0005\u0157\u00ac\u0002\u02d7\u02d8\u0005\u0161\u00b1\u0002',
+  '\u02d8\u02d9\u0005\u0175\u00bb\u0002\u02d9\u02da\u0005\u0177\u00bc\u0002',
+  '\u02da\u02db\u0005\u0161\u00b1\u0002\u02db\u02dc\u0005\u016b\u00b6\u0002',
+  '\u02dc\u02dd\u0005\u0155\u00ab\u0002\u02dd\u02de\u0005\u0177\u00bc\u0002',
+  '\u02de\u00b2\u0003\u0002\u0002\u0002\u02df\u02e0\u0005\u0173\u00ba\u0002',
+  '\u02e0\u02e1\u0005\u0159\u00ad\u0002\u02e1\u02e2\u0005\u0177\u00bc\u0002',
+  '\u02e2\u02e3\u0005\u0179\u00bd\u0002\u02e3\u02e4\u0005\u0173\u00ba\u0002',
+  '\u02e4\u02e5\u0005\u016b\u00b6\u0002\u02e5\u00b4\u0003\u0002\u0002\u0002',
+  '\u02e6\u02e7\u0005\u016d\u00b7\u0002\u02e7\u02e8\u0005\u0173\u00ba\u0002',
+  '\u02e8\u02e9\u0005\u0157\u00ac\u0002\u02e9\u02ea\u0005\u0159\u00ad\u0002',
+  '\u02ea\u02eb\u0005\u0173\u00ba\u0002\u02eb\u00b6\u0003\u0002\u0002\u0002',
+  '\u02ec\u02ed\u0005\u0153\u00aa\u0002\u02ed\u02ee\u0005\u0181\u00c1\u0002',
+  '\u02ee\u00b8\u0003\u0002\u0002\u0002\u02ef\u02f0\u0005\u0175\u00bb\u0002',
+  '\u02f0\u02f1\u0005\u0165\u00b3\u0002\u02f1\u02f2\u0005\u0161\u00b1\u0002',
+  '\u02f2\u02f3\u0005\u016f\u00b8\u0002\u02f3\u00ba\u0003\u0002\u0002\u0002',
+  '\u02f4\u02f5\u0005\u0167\u00b4\u0002\u02f5\u02f6\u0005\u0161\u00b1\u0002',
+  '\u02f6\u02f7\u0005\u0169\u00b5\u0002\u02f7\u02f8\u0005\u0161\u00b1\u0002',
+  '\u02f8\u02f9\u0005\u0177\u00bc\u0002\u02f9\u00bc\u0003\u0002\u0002\u0002',
+  '\u02fa\u02fb\u0005\u0151\u00a9\u0002\u02fb\u02fc\u0005\u0175\u00bb\u0002',
+  '\u02fc\u02fd\u0005\u0155\u00ab\u0002\u02fd\u02fe\u0005\u0159\u00ad\u0002',
+  '\u02fe\u02ff\u0005\u016b\u00b6\u0002\u02ff\u0300\u0005\u0157\u00ac\u0002',
+  '\u0300\u0301\u0005\u0161\u00b1\u0002\u0301\u0302\u0005\u016b\u00b6\u0002',
+  '\u0302\u0303\u0005\u015d\u00af\u0002\u0303\u00be\u0003\u0002\u0002\u0002',
+  '\u0304\u0305\u0005\u0151\u00a9\u0002\u0305\u0306\u0005\u0175\u00bb\u0002',
+  '\u0306\u0307\u0005\u0155\u00ab\u0002\u0307\u00c0\u0003\u0002\u0002\u0002',
+  '\u0308\u0309\u0005\u0157\u00ac\u0002\u0309\u030a\u0005\u0159\u00ad\u0002',
+  '\u030a\u030b\u0005\u0175\u00bb\u0002\u030b\u030c\u0005\u0155\u00ab\u0002',
+  '\u030c\u030d\u0005\u0159\u00ad\u0002\u030d\u030e\u0005\u016b\u00b6\u0002',
+  '\u030e\u030f\u0005\u0157\u00ac\u0002\u030f\u0310\u0005\u0161\u00b1\u0002',
+  '\u0310\u0311\u0005\u016b\u00b6\u0002\u0311\u0312\u0005\u015d\u00af\u0002',
+  '\u0312\u00c2\u0003\u0002\u0002\u0002\u0313\u0314\u0005\u0157\u00ac\u0002',
+  '\u0314\u0315\u0005\u0159\u00ad\u0002\u0315\u0316\u0005\u0175\u00bb\u0002',
+  '\u0316\u0317\u0005\u0155\u00ab\u0002\u0317\u00c4\u0003\u0002\u0002\u0002',
+  '\u0318\u0319\u0005\u0163\u00b2\u0002\u0319\u031a\u0005\u016d\u00b7\u0002',
+  '\u031a\u031b\u0005\u0161\u00b1\u0002\u031b\u031c\u0005\u016b\u00b6\u0002',
+  '\u031c\u00c6\u0003\u0002\u0002\u0002\u031d\u031e\u0005\u0175\u00bb\u0002',
+  '\u031e\u031f\u0005\u0155\u00ab\u0002\u031f\u0320\u0005\u0151\u00a9\u0002',
+  '\u0320\u0321\u0005\u016b\u00b6\u0002\u0321\u00c8\u0003\u0002\u0002\u0002',
+  '\u0322\u0323\u0005\u0175\u00bb\u0002\u0323\u0324\u0005\u0177\u00bc\u0002',
+  '\u0324\u0325\u0005\u0151\u00a9\u0002\u0325\u0326\u0005\u0173\u00ba\u0002',
+  '\u0326\u0327\u0005\u0177\u00bc\u0002\u0327\u00ca\u0003\u0002\u0002\u0002',
+  '\u0328\u0329\u0005\u016b\u00b6\u0002\u0329\u032a\u0005\u016d\u00b7\u0002',
+  '\u032a\u032b\u0005\u0157\u00ac\u0002\u032b\u032c\u0005\u0159\u00ad\u0002',
+  '\u032c\u00cc\u0003\u0002\u0002\u0002\u032d\u032e\u0005\u0173\u00ba\u0002',
+  '\u032e\u032f\u0005\u0159\u00ad\u0002\u032f\u0330\u0005\u0167\u00b4\u0002',
+  '\u0330\u0331\u0005\u0151\u00a9\u0002\u0331\u0332\u0005\u0177\u00bc\u0002',
+  '\u0332\u0333\u0005\u0161\u00b1\u0002\u0333\u0334\u0005\u016d\u00b7\u0002',
+  '\u0334\u0335\u0005\u016b\u00b6\u0002\u0335\u0336\u0005\u0175\u00bb\u0002',
+  '\u0336\u0337\u0005\u015f\u00b0\u0002\u0337\u0338\u0005\u0161\u00b1\u0002',
+  '\u0338\u0339\u0005\u016f\u00b8\u0002\u0339\u00ce\u0003\u0002\u0002\u0002',
+  '\u033a\u033b\u0005\u0173\u00ba\u0002\u033b\u033c\u0005\u0159\u00ad\u0002',
+  '\u033c\u033d\u0005\u0167\u00b4\u0002\u033d\u00d0\u0003\u0002\u0002\u0002',
+  '\u033e\u033f\u0005\u017d\u00bf\u0002\u033f\u0340\u0005\u015f\u00b0\u0002',
+  '\u0340\u0341\u0005\u0159\u00ad\u0002\u0341\u0342\u0005\u0173\u00ba\u0002',
+  '\u0342\u0343\u0005\u0159\u00ad\u0002\u0343\u00d2\u0003\u0002\u0002\u0002',
+  '\u0344\u0345\u0005\u0175\u00bb\u0002\u0345\u0346\u0005\u015f\u00b0\u0002',
+  '\u0346\u0347\u0005\u016d\u00b7\u0002\u0347\u0348\u0005\u0173\u00ba\u0002',
+  '\u0348\u0349\u0005\u0177\u00bc\u0002\u0349\u034a\u0005\u0159\u00ad\u0002',
+  '\u034a\u034b\u0005\u0175\u00bb\u0002\u034b\u034c\u0005\u0177\u00bc\u0002',
+  '\u034c\u034d\u0005\u016f\u00b8\u0002\u034d\u034e\u0005\u0151\u00a9\u0002',
+  '\u034e\u034f\u0005\u0177\u00bc\u0002\u034f\u0350\u0005\u015f\u00b0\u0002',
+  '\u0350\u00d4\u0003\u0002\u0002\u0002\u0351\u0352\u0005\u0151\u00a9\u0002',
+  '\u0352\u0353\u0005\u0167\u00b4\u0002\u0353\u0354\u0005\u0167\u00b4\u0002',
+  '\u0354\u0355\u0005\u0175\u00bb\u0002\u0355\u0356\u0005\u015f\u00b0\u0002',
+  '\u0356\u0357\u0005\u016d\u00b7\u0002\u0357\u0358\u0005\u0173\u00ba\u0002',
+  '\u0358\u0359\u0005\u0177\u00bc\u0002\u0359\u035a\u0005\u0159\u00ad\u0002',
+  '\u035a\u035b\u0005\u0175\u00bb\u0002\u035b\u035c\u0005\u0177\u00bc\u0002',
+  '\u035c\u035d\u0005\u016f\u00b8\u0002\u035d\u035e\u0005\u0151\u00a9\u0002',
+  '\u035e\u035f\u0005\u0177\u00bc\u0002\u035f\u0360\u0005\u015f\u00b0\u0002',
+  '\u0360\u0361\u0005\u0175\u00bb\u0002\u0361\u00d6\u0003\u0002\u0002\u0002',
+  '\u0362\u0363\u0005\u016d\u00b7\u0002\u0363\u0364\u0005\u0173\u00ba\u0002',
+  '\u0364\u00d8\u0003\u0002\u0002\u0002\u0365\u0366\u0005\u017f\u00c0\u0002',
+  '\u0366\u0367\u0005\u016d\u00b7\u0002\u0367\u0368\u0005\u0173\u00ba\u0002',
+  '\u0368\u00da\u0003\u0002\u0002\u0002\u0369\u036a\u0005\u0151\u00a9\u0002',
+  '\u036a\u036b\u0005\u016b\u00b6\u0002\u036b\u036c\u0005\u0157\u00ac\u0002',
+  '\u036c\u00dc\u0003\u0002\u0002\u0002\u036d\u036e\u0005\u016b\u00b6\u0002',
+  '\u036e\u036f\u0005\u016d\u00b7\u0002\u036f\u0370\u0005\u0177\u00bc\u0002',
+  '\u0370\u00de\u0003\u0002\u0002\u0002\u0371\u0372\u0005\u0175\u00bb\u0002',
+  '\u0372\u0373\u0005\u0177\u00bc\u0002\u0373\u0374\u0005\u0151\u00a9\u0002',
+  '\u0374\u0375\u0005\u0173\u00ba\u0002\u0375\u0376\u0005\u0177\u00bc\u0002',
+  '\u0376\u0377\u0005\u0175\u00bb\u0002\u0377\u00e0\u0003\u0002\u0002\u0002',
+  '\u0378\u0379\u0005\u0159\u00ad\u0002\u0379\u037a\u0005\u016b\u00b6\u0002',
+  '\u037a\u037b\u0005\u0157\u00ac\u0002\u037b\u037c\u0005\u0175\u00bb\u0002',
+  '\u037c\u00e2\u0003\u0002\u0002\u0002\u037d\u037e\u0005\u0155\u00ab\u0002',
+  '\u037e\u037f\u0005\u016d\u00b7\u0002\u037f\u0380\u0005\u016b\u00b6\u0002',
+  '\u0380\u0381\u0005\u0177\u00bc\u0002\u0381\u0382\u0005\u0151\u00a9\u0002',
+  '\u0382\u0383\u0005\u0161\u00b1\u0002\u0383\u0384\u0005\u016b\u00b6\u0002',
+  '\u0384\u0385\u0005\u0175\u00bb\u0002\u0385\u00e4\u0003\u0002\u0002\u0002',
+  '\u0386\u0387\u0005\u016b\u00b6\u0002\u0387\u0388\u0005\u0179\u00bd\u0002',
+  '\u0388\u0389\u0005\u0167\u00b4\u0002\u0389\u038a\u0005\u0167\u00b4\u0002',
+  '\u038a\u00e6\u0003\u0002\u0002\u0002\u038b\u038c\u0005\u0155\u00ab\u0002',
+  '\u038c\u038d\u0005\u016d\u00b7\u0002\u038d\u038e\u0005\u0179\u00bd\u0002',
+  '\u038e\u038f\u0005\u016b\u00b6\u0002\u038f\u0390\u0005\u0177\u00bc\u0002',
+  '\u0390\u00e8\u0003\u0002\u0002\u0002\u0391\u0392\u0005\u015b\u00ae\u0002',
+  '\u0392\u0393\u0005\u0161\u00b1\u0002\u0393\u0394\u0005\u0167\u00b4\u0002',
+  '\u0394\u0395\u0005\u0177\u00bc\u0002\u0395\u0396\u0005\u0159\u00ad\u0002',
+  '\u0396\u0397\u0005\u0173\u00ba\u0002\u0397\u00ea\u0003\u0002\u0002\u0002',
+  '\u0398\u0399\u0005\u0159\u00ad\u0002\u0399\u039a\u0005\u017f\u00c0\u0002',
+  '\u039a\u039b\u0005\u0177\u00bc\u0002\u039b\u039c\u0005\u0173\u00ba\u0002',
+  '\u039c\u039d\u0005\u0151\u00a9\u0002\u039d\u039e\u0005\u0155\u00ab\u0002',
+  '\u039e\u039f\u0005\u0177\u00bc\u0002\u039f\u00ec\u0003\u0002\u0002\u0002',
+  '\u03a0\u03a1\u0005\u0151\u00a9\u0002\u03a1\u03a2\u0005\u016b\u00b6\u0002',
+  '\u03a2\u03a3\u0005\u0181\u00c1\u0002\u03a3\u00ee\u0003\u0002\u0002\u0002',
+  '\u03a4\u03a5\u0005\u016b\u00b6\u0002\u03a5\u03a6\u0005\u016d\u00b7\u0002',
+  '\u03a6\u03a7\u0005\u016b\u00b6\u0002\u03a7\u03a8\u0005\u0159\u00ad\u0002',
+  '\u03a8\u00f0\u0003\u0002\u0002\u0002\u03a9\u03aa\u0005\u0175\u00bb\u0002',
+  '\u03aa\u03ab\u0005\u0161\u00b1\u0002\u03ab\u03ac\u0005\u016b\u00b6\u0002',
+  '\u03ac\u03ad\u0005\u015d\u00af\u0002\u03ad\u03ae\u0005\u0167\u00b4\u0002',
+  '\u03ae\u03af\u0005\u0159\u00ad\u0002\u03af\u00f2\u0003\u0002\u0002\u0002',
+  '\u03b0\u03b1\u0005\u0177\u00bc\u0002\u03b1\u03b2\u0005\u0173\u00ba\u0002',
+  '\u03b2\u03b3\u0005\u0179\u00bd\u0002\u03b3\u03b4\u0005\u0159\u00ad\u0002',
+  '\u03b4\u00f4\u0003\u0002\u0002\u0002\u03b5\u03b6\u0005\u015b\u00ae\u0002',
+  '\u03b6\u03b7\u0005\u0151\u00a9\u0002\u03b7\u03b8\u0005\u0167\u00b4\u0002',
+  '\u03b8\u03b9\u0005\u0175\u00bb\u0002\u03b9\u03ba\u0005\u0159\u00ad\u0002',
+  '\u03ba\u00f6\u0003\u0002\u0002\u0002\u03bb\u03bc\u0005\u0173\u00ba\u0002',
+  '\u03bc\u03bd\u0005\u0159\u00ad\u0002\u03bd\u03be\u0005\u0157\u00ac\u0002',
+  '\u03be\u03bf\u0005\u0179\u00bd\u0002\u03bf\u03c0\u0005\u0155\u00ab\u0002',
+  '\u03c0\u03c1\u0005\u0159\u00ad\u0002\u03c1\u00f8\u0003\u0002\u0002\u0002',
+  '\u03c2\u03c3\u0005\u0155\u00ab\u0002\u03c3\u03c4\u0005\u0151\u00a9\u0002',
+  '\u03c4\u03c5\u0005\u0175\u00bb\u0002\u03c5\u03c6\u0005\u0159\u00ad\u0002',
+  '\u03c6\u00fa\u0003\u0002\u0002\u0002\u03c7\u03c8\u0005\u0159\u00ad\u0002',
+  '\u03c8\u03c9\u0005\u0167\u00b4\u0002\u03c9\u03ca\u0005\u0175\u00bb\u0002',
+  '\u03ca\u03cb\u0005\u0159\u00ad\u0002\u03cb\u00fc\u0003\u0002\u0002\u0002',
+  '\u03cc\u03cd\u0005\u0159\u00ad\u0002\u03cd\u03ce\u0005\u016b\u00b6\u0002',
+  '\u03ce\u03cf\u0005\u0157\u00ac\u0002\u03cf\u00fe\u0003\u0002\u0002\u0002',
+  '\u03d0\u03d1\u0005\u017d\u00bf\u0002\u03d1\u03d2\u0005\u015f\u00b0\u0002',
+  '\u03d2\u03d3\u0005\u0159\u00ad\u0002\u03d3\u03d4\u0005\u016b\u00b6\u0002',
+  '\u03d4\u0100\u0003\u0002\u0002\u0002\u03d5\u03d6\u0005\u0177\u00bc\u0002',
+  '\u03d6\u03d7\u0005\u015f\u00b0\u0002\u03d7\u03d8\u0005\u0159\u00ad\u0002',
+  '\u03d8\u03d9\u0005\u016b\u00b6\u0002\u03d9\u0102\u0003\u0002\u0002\u0002',
+  '\u03da\u03db\u0005\u0155\u00ab\u0002\u03db\u03dc\u0005\u0151\u00a9\u0002',
+  '\u03dc\u03dd\u0005\u0167\u00b4\u0002\u03dd\u03de\u0005\u0167\u00b4\u0002',
+  '\u03de\u0104\u0003\u0002\u0002\u0002\u03df\u03e0\u0005\u0181\u00c1\u0002',
+  '\u03e0\u03e1\u0005\u0161\u00b1\u0002\u03e1\u03e2\u0005\u0159\u00ad\u0002',
+  '\u03e2\u03e3\u0005\u0167\u00b4\u0002\u03e3\u03e4\u0005\u0157\u00ac\u0002',
+  '\u03e4\u0106\u0003\u0002\u0002\u0002\u03e5\u03e6\u0005\u0165\u00b3\u0002',
+  '\u03e6\u03e7\u0005\u0159\u00ad\u0002\u03e7\u03e8\u0005\u0181\u00c1\u0002',
+  '\u03e8\u0108\u0003\u0002\u0002\u0002\u03e9\u03f2\u0007$\u0002\u0002',
+  '\u03ea\u03f1\n\u0002\u0002\u0002\u03eb\u03ee\u0007^\u0002\u0002\u03ec',
+  '\u03ef\u000b\u0002\u0002\u0002\u03ed\u03ef\u0007\u0002\u0002\u0003\u03ee',
+  '\u03ec\u0003\u0002\u0002\u0002\u03ee\u03ed\u0003\u0002\u0002\u0002\u03ef',
+  '\u03f1\u0003\u0002\u0002\u0002\u03f0\u03ea\u0003\u0002\u0002\u0002\u03f0',
+  '\u03eb\u0003\u0002\u0002\u0002\u03f1\u03f4\u0003\u0002\u0002\u0002\u03f2',
+  '\u03f0\u0003\u0002\u0002\u0002\u03f2\u03f3\u0003\u0002\u0002\u0002\u03f3',
+  '\u03f5\u0003\u0002\u0002\u0002\u03f4\u03f2\u0003\u0002\u0002\u0002\u03f5',
+  '\u0404\u0007$\u0002\u0002\u03f6\u03ff\u0007)\u0002\u0002\u03f7\u03fe',
+  '\n\u0003\u0002\u0002\u03f8\u03fb\u0007^\u0002\u0002\u03f9\u03fc\u000b',
+  '\u0002\u0002\u0002\u03fa\u03fc\u0007\u0002\u0002\u0003\u03fb\u03f9\u0003',
+  '\u0002\u0002\u0002\u03fb\u03fa\u0003\u0002\u0002\u0002\u03fc\u03fe\u0003',
+  '\u0002\u0002\u0002\u03fd\u03f7\u0003\u0002\u0002\u0002\u03fd\u03f8\u0003',
+  '\u0002\u0002\u0002\u03fe\u0401\u0003\u0002\u0002\u0002\u03ff\u03fd\u0003',
+  '\u0002\u0002\u0002\u03ff\u0400\u0003\u0002\u0002\u0002\u0400\u0402\u0003',
+  '\u0002\u0002\u0002\u0401\u03ff\u0003\u0002\u0002\u0002\u0402\u0404\u0007',
+  ')\u0002\u0002\u0403\u03e9\u0003\u0002\u0002\u0002\u0403\u03f6\u0003',
+  '\u0002\u0002\u0002\u0404\u010a\u0003\u0002\u0002\u0002\u0405\u0406\u0007',
+  "'\u0002\u0002\u0406\u0407\t\u0004\u0002\u0002\u0407\u0409\t\u0004\u0002",
+  '\u0002\u0408\u0405\u0003\u0002\u0002\u0002\u0409\u040a\u0003\u0002\u0002',
+  '\u0002\u040a\u0408\u0003\u0002\u0002\u0002\u040a\u040b\u0003\u0002\u0002',
+  '\u0002\u040b\u010c\u0003\u0002\u0002\u0002\u040c\u041e\u0007^\u0002',
+  '\u0002\u040d\u041f\t\u0005\u0002\u0002\u040e\u040f\t\u0006\u0002\u0002',
+  '\u040f\u0410\u0005\u0117\u008c\u0002\u0410\u0411\u0005\u0117\u008c\u0002',
+  '\u0411\u0412\u0005\u0117\u008c\u0002\u0412\u0413\u0005\u0117\u008c\u0002',
+  '\u0413\u041f\u0003\u0002\u0002\u0002\u0414\u0415\t\u0006\u0002\u0002',
+  '\u0415\u0416\u0005\u0117\u008c\u0002\u0416\u0417\u0005\u0117\u008c\u0002',
+  '\u0417\u0418\u0005\u0117\u008c\u0002\u0418\u0419\u0005\u0117\u008c\u0002',
+  '\u0419\u041a\u0005\u0117\u008c\u0002\u041a\u041b\u0005\u0117\u008c\u0002',
+  '\u041b\u041c\u0005\u0117\u008c\u0002\u041c\u041d\u0005\u0117\u008c\u0002',
+  '\u041d\u041f\u0003\u0002\u0002\u0002\u041e\u040d\u0003\u0002\u0002\u0002',
+  '\u041e\u040e\u0003\u0002\u0002\u0002\u041e\u0414\u0003\u0002\u0002\u0002',
+  '\u041f\u010e\u0003\u0002\u0002\u0002\u0420\u0421\u00072\u0002\u0002',
+  '\u0421\u0422\u0007z\u0002\u0002\u0422\u0424\u0003\u0002\u0002\u0002',
+  '\u0423\u0425\u0005\u0117\u008c\u0002\u0424\u0423\u0003\u0002\u0002\u0002',
+  '\u0425\u0426\u0003\u0002\u0002\u0002\u0426\u0424\u0003\u0002\u0002\u0002',
+  '\u0426\u0427\u0003\u0002\u0002\u0002\u0427\u0110\u0003\u0002\u0002\u0002',
+  '\u0428\u0431\u0005\u0121\u0091\u0002\u0429\u042d\u0005\u011b\u008e\u0002',
+  '\u042a\u042c\u0005\u0119\u008d\u0002\u042b\u042a\u0003\u0002\u0002\u0002',
+  '\u042c\u042f\u0003\u0002\u0002\u0002\u042d\u042b\u0003\u0002\u0002\u0002',
+  '\u042d\u042e\u0003\u0002\u0002\u0002\u042e\u0431\u0003\u0002\u0002\u0002',
+  '\u042f\u042d\u0003\u0002\u0002\u0002\u0430\u0428\u0003\u0002\u0002\u0002',
+  '\u0430\u0429\u0003\u0002\u0002\u0002\u0431\u0112\u0003\u0002\u0002\u0002',
+  '\u0432\u0434\u0005\u0121\u0091\u0002\u0433\u0435\u0005\u011f\u0090\u0002',
+  '\u0434\u0433\u0003\u0002\u0002\u0002\u0435\u0436\u0003\u0002\u0002\u0002',
+  '\u0436\u0434\u0003\u0002\u0002\u0002\u0436\u0437\u0003\u0002\u0002\u0002',
+  '\u0437\u0114\u0003\u0002\u0002\u0002\u0438\u043a\t\u0007\u0002\u0002',
+  '\u0439\u0438\u0003\u0002\u0002\u0002\u043a\u0116\u0003\u0002\u0002\u0002',
+  '\u043b\u043e\u0005\u0119\u008d\u0002\u043c\u043e\u0005\u0115\u008b\u0002',
+  '\u043d\u043b\u0003\u0002\u0002\u0002\u043d\u043c\u0003\u0002\u0002\u0002',
+  '\u043e\u0118\u0003\u0002\u0002\u0002\u043f\u0442\u0005\u0121\u0091\u0002',
+  '\u0440\u0442\u0005\u011b\u008e\u0002\u0441\u043f\u0003\u0002\u0002\u0002',
+  '\u0441\u0440\u0003\u0002\u0002\u0002\u0442\u011a\u0003\u0002\u0002\u0002',
+  '\u0443\u0446\u0005\u011d\u008f\u0002\u0444\u0446\u0004:;\u0002\u0445',
+  '\u0443\u0003\u0002\u0002\u0002\u0445\u0444\u0003\u0002\u0002\u0002\u0446',
+  '\u011c\u0003\u0002\u0002\u0002\u0447\u0448\u000439\u0002\u0448\u011e',
+  '\u0003\u0002\u0002\u0002\u0449\u044c\u0005\u0121\u0091\u0002\u044a\u044c',
+  '\u0005\u011d\u008f\u0002\u044b\u0449\u0003\u0002\u0002\u0002\u044b\u044a',
+  '\u0003\u0002\u0002\u0002\u044c\u0120\u0003\u0002\u0002\u0002\u044d\u044e',
+  '\u00072\u0002\u0002\u044e\u0122\u0003\u0002\u0002\u0002\u044f\u0451',
+  '\u0005\u0119\u008d\u0002\u0450\u044f\u0003\u0002\u0002\u0002\u0451\u0452',
+  '\u0003\u0002\u0002\u0002\u0452\u0450\u0003\u0002\u0002\u0002\u0452\u0453',
+  '\u0003\u0002\u0002\u0002\u0453\u0466\u0003\u0002\u0002\u0002\u0454\u0456',
+  '\u0005\u0119\u008d\u0002\u0455\u0454\u0003\u0002\u0002\u0002\u0456\u0457',
+  '\u0003\u0002\u0002\u0002\u0457\u0455\u0003\u0002\u0002\u0002\u0457\u0458',
+  '\u0003\u0002\u0002\u0002\u0458\u0459\u0003\u0002\u0002\u0002\u0459\u045b',
+  '\u00070\u0002\u0002\u045a\u045c\u0005\u0119\u008d\u0002\u045b\u045a',
+  '\u0003\u0002\u0002\u0002\u045c\u045d\u0003\u0002\u0002\u0002\u045d\u045b',
+  '\u0003\u0002\u0002\u0002\u045d\u045e\u0003\u0002\u0002\u0002\u045e\u0466',
+  '\u0003\u0002\u0002\u0002\u045f\u0461\u00070\u0002\u0002\u0460\u0462',
+  '\u0005\u0119\u008d\u0002\u0461\u0460\u0003\u0002\u0002\u0002\u0462\u0463',
+  '\u0003\u0002\u0002\u0002\u0463\u0461\u0003\u0002\u0002\u0002\u0463\u0464',
+  '\u0003\u0002\u0002\u0002\u0464\u0466\u0003\u0002\u0002\u0002\u0465\u0450',
+  '\u0003\u0002\u0002\u0002\u0465\u0455\u0003\u0002\u0002\u0002\u0465\u045f',
+  '\u0003\u0002\u0002\u0002\u0466\u0467\u0003\u0002\u0002\u0002\u0467\u0469',
+  '\t\b\u0002\u0002\u0468\u046a\u0007/\u0002\u0002\u0469\u0468\u0003\u0002',
+  '\u0002\u0002\u0469\u046a\u0003\u0002\u0002\u0002\u046a\u046c\u0003\u0002',
+  '\u0002\u0002\u046b\u046d\u0005\u0119\u008d\u0002\u046c\u046b\u0003\u0002',
+  '\u0002\u0002\u046d\u046e\u0003\u0002\u0002\u0002\u046e\u046c\u0003\u0002',
+  '\u0002\u0002\u046e\u046f\u0003\u0002\u0002\u0002\u046f\u0124\u0003\u0002',
+  '\u0002\u0002\u0470\u0472\u0005\u0119\u008d\u0002\u0471\u0470\u0003\u0002',
+  '\u0002\u0002\u0472\u0475\u0003\u0002\u0002\u0002\u0473\u0471\u0003\u0002',
+  '\u0002\u0002\u0473\u0474\u0003\u0002\u0002\u0002\u0474\u0476\u0003\u0002',
+  '\u0002\u0002\u0475\u0473\u0003\u0002\u0002\u0002\u0476\u0478\u00070',
+  '\u0002\u0002\u0477\u0479\u0005\u0119\u008d\u0002\u0478\u0477\u0003\u0002',
+  '\u0002\u0002\u0479\u047a\u0003\u0002\u0002\u0002\u047a\u0478\u0003\u0002',
+  '\u0002\u0002\u047a\u047b\u0003\u0002\u0002\u0002\u047b\u0126\u0003\u0002',
+  '\u0002\u0002\u047c\u0480\u0005\u0129\u0095\u0002\u047d\u047f\u0005\u012b',
+  '\u0096\u0002\u047e\u047d\u0003\u0002\u0002\u0002\u047f\u0482\u0003\u0002',
+  '\u0002\u0002\u0480\u047e\u0003\u0002\u0002\u0002\u0480\u0481\u0003\u0002',
+  '\u0002\u0002\u0481\u0128\u0003\u0002\u0002\u0002\u0482\u0480\u0003\u0002',
+  '\u0002\u0002\u0483\u0486\u0005\u014f\u00a8\u0002\u0484\u0486\t\t\u0002',
+  '\u0002\u0485\u0483\u0003\u0002\u0002\u0002\u0485\u0484\u0003\u0002\u0002',
+  '\u0002\u0486\u012a\u0003\u0002\u0002\u0002\u0487\u048a\u0005\u013b\u009e',
+  '\u0002\u0488\u048a\u0005\u0143\u00a2\u0002\u0489\u0487\u0003\u0002\u0002',
+  '\u0002\u0489\u0488\u0003\u0002\u0002\u0002\u048a\u012c\u0003\u0002\u0002',
+  '\u0002\u048b\u0491\u0007b\u0002\u0002\u048c\u0490\n\n\u0002\u0002\u048d',
+  '\u048e\u0007b\u0002\u0002\u048e\u0490\u0007b\u0002\u0002\u048f\u048c',
+  '\u0003\u0002\u0002\u0002\u048f\u048d\u0003\u0002\u0002\u0002\u0490\u0493',
+  '\u0003\u0002\u0002\u0002\u0491\u048f\u0003\u0002\u0002\u0002\u0491\u0492',
+  '\u0003\u0002\u0002\u0002\u0492\u0494\u0003\u0002\u0002\u0002\u0493\u0491',
+  '\u0003\u0002\u0002\u0002\u0494\u0495\u0007b\u0002\u0002\u0495\u012e',
+  '\u0003\u0002\u0002\u0002\u0496\u0498\u0005\u0131\u0099\u0002\u0497\u0496',
+  '\u0003\u0002\u0002\u0002\u0498\u0499\u0003\u0002\u0002\u0002\u0499\u0497',
+  '\u0003\u0002\u0002\u0002\u0499\u049a\u0003\u0002\u0002\u0002\u049a\u0130',
+  '\u0003\u0002\u0002\u0002\u049b\u04a8\u0005\u0145\u00a3\u0002\u049c\u04a8',
+  '\u0005\u0147\u00a4\u0002\u049d\u04a8\u0005\u0149\u00a5\u0002\u049e\u04a8',
+  '\u0005\u014b\u00a6\u0002\u049f\u04a8\u0005\u0137\u009c\u0002\u04a0\u04a8',
+  '\u0005\u0141\u00a1\u0002\u04a1\u04a8\u0005\u013f\u00a0\u0002\u04a2\u04a8',
+  '\u0005\u013d\u009f\u0002\u04a3\u04a8\u0005\u0139\u009d\u0002\u04a4\u04a8',
+  '\u0005\u014d\u00a7\u0002\u04a5\u04a8\t\u000b\u0002\u0002\u04a6\u04a8',
+  '\u0005\u0133\u009a\u0002\u04a7\u049b\u0003\u0002\u0002\u0002\u04a7\u049c',
+  '\u0003\u0002\u0002\u0002\u04a7\u049d\u0003\u0002\u0002\u0002\u04a7\u049e',
+  '\u0003\u0002\u0002\u0002\u04a7\u049f\u0003\u0002\u0002\u0002\u04a7\u04a0',
+  '\u0003\u0002\u0002\u0002\u04a7\u04a1\u0003\u0002\u0002\u0002\u04a7\u04a2',
+  '\u0003\u0002\u0002\u0002\u04a7\u04a3\u0003\u0002\u0002\u0002\u04a7\u04a4',
+  '\u0003\u0002\u0002\u0002\u04a7\u04a5\u0003\u0002\u0002\u0002\u04a7\u04a6',
+  '\u0003\u0002\u0002\u0002\u04a8\u0132\u0003\u0002\u0002\u0002\u04a9\u04aa',
+  '\u00071\u0002\u0002\u04aa\u04ab\u0007,\u0002\u0002\u04ab\u04af\u0003',
+  '\u0002\u0002\u0002\u04ac\u04ae\u000b\u0002\u0002\u0002\u04ad\u04ac\u0003',
+  '\u0002\u0002\u0002\u04ae\u04b1\u0003\u0002\u0002\u0002\u04af\u04b0\u0003',
+  '\u0002\u0002\u0002\u04af\u04ad\u0003\u0002\u0002\u0002\u04b0\u04b2\u0003',
+  '\u0002\u0002\u0002\u04b1\u04af\u0003\u0002\u0002\u0002\u04b2\u04b3\u0007',
+  ',\u0002\u0002\u04b3\u04be\u00071\u0002\u0002\u04b4\u04b5\u00071\u0002',
+  '\u0002\u04b5\u04b6\u00071\u0002\u0002\u04b6\u04ba\u0003\u0002\u0002',
+  '\u0002\u04b7\u04b9\n\f\u0002\u0002\u04b8\u04b7\u0003\u0002\u0002\u0002',
+  '\u04b9\u04bc\u0003\u0002\u0002\u0002\u04ba\u04b8\u0003\u0002\u0002\u0002',
+  '\u04ba\u04bb\u0003\u0002\u0002\u0002\u04bb\u04be\u0003\u0002\u0002\u0002',
+  '\u04bc\u04ba\u0003\u0002\u0002\u0002\u04bd\u04a9\u0003\u0002\u0002\u0002',
+  '\u04bd\u04b4\u0003\u0002\u0002\u0002\u04be\u0134\u0003\u0002\u0002\u0002',
+  '\u04bf\u04c0\u000b\u0002\u0002\u0002\u04c0\u0136\u0003\u0002\u0002\u0002',
+  '\u04c1\u04c2\t\r\u0002\u0002\u04c2\u0138\u0003\u0002\u0002\u0002\u04c3',
+  '\u04c4\t\u000e\u0002\u0002\u04c4\u013a\u0003\u0002\u0002\u0002\u04c5',
+  '\u04c6\t\u000f\u0002\u0002\u04c6\u013c\u0003\u0002\u0002\u0002\u04c7',
+  '\u04c8\t\u0010\u0002\u0002\u04c8\u013e\u0003\u0002\u0002\u0002\u04c9',
+  '\u04ca\t\u0011\u0002\u0002\u04ca\u0140\u0003\u0002\u0002\u0002\u04cb',
+  '\u04cc\t\u0012\u0002\u0002\u04cc\u0142\u0003\u0002\u0002\u0002\u04cd',
+  '\u04ce\t\u0013\u0002\u0002\u04ce\u0144\u0003\u0002\u0002\u0002\u04cf',
+  '\u04d0\t\u0014\u0002\u0002\u04d0\u0146\u0003\u0002\u0002\u0002\u04d1',
+  '\u04d2\t\u0015\u0002\u0002\u04d2\u0148\u0003\u0002\u0002\u0002\u04d3',
+  '\u04d4\t\u0016\u0002\u0002\u04d4\u014a\u0003\u0002\u0002\u0002\u04d5',
+  '\u04d6\t\u0017\u0002\u0002\u04d6\u014c\u0003\u0002\u0002\u0002\u04d7',
+  '\u04d8\t\u0018\u0002\u0002\u04d8\u014e\u0003\u0002\u0002\u0002\u04d9',
+  '\u04da\t\u0019\u0002\u0002\u04da\u0150\u0003\u0002\u0002\u0002\u04db',
+  '\u04dc\t\u001a\u0002\u0002\u04dc\u0152\u0003\u0002\u0002\u0002\u04dd',
+  '\u04de\t\u001b\u0002\u0002\u04de\u0154\u0003\u0002\u0002\u0002\u04df',
+  '\u04e0\t\u001c\u0002\u0002\u04e0\u0156\u0003\u0002\u0002\u0002\u04e1',
+  '\u04e2\t\u001d\u0002\u0002\u04e2\u0158\u0003\u0002\u0002\u0002\u04e3',
+  '\u04e4\t\b\u0002\u0002\u04e4\u015a\u0003\u0002\u0002\u0002\u04e5\u04e6',
+  '\t\u001e\u0002\u0002\u04e6\u015c\u0003\u0002\u0002\u0002\u04e7\u04e8',
+  '\t\u001f\u0002\u0002\u04e8\u015e\u0003\u0002\u0002\u0002\u04e9\u04ea',
+  '\t \u0002\u0002\u04ea\u0160\u0003\u0002\u0002\u0002\u04eb\u04ec\t!\u0002',
+  '\u0002\u04ec\u0162\u0003\u0002\u0002\u0002\u04ed\u04ee\t"\u0002\u0002',
+  '\u04ee\u0164\u0003\u0002\u0002\u0002\u04ef\u04f0\t#\u0002\u0002\u04f0',
+  '\u0166\u0003\u0002\u0002\u0002\u04f1\u04f2\t$\u0002\u0002\u04f2\u0168',
+  '\u0003\u0002\u0002\u0002\u04f3\u04f4\t%\u0002\u0002\u04f4\u016a\u0003',
+  '\u0002\u0002\u0002\u04f5\u04f6\t&\u0002\u0002\u04f6\u016c\u0003\u0002',
+  "\u0002\u0002\u04f7\u04f8\t'\u0002\u0002\u04f8\u016e\u0003\u0002\u0002",
+  '\u0002\u04f9\u04fa\t(\u0002\u0002\u04fa\u0170\u0003\u0002\u0002\u0002',
+  '\u04fb\u04fc\t)\u0002\u0002\u04fc\u0172\u0003\u0002\u0002\u0002\u04fd',
+  '\u04fe\t*\u0002\u0002\u04fe\u0174\u0003\u0002\u0002\u0002\u04ff\u0500',
+  '\t+\u0002\u0002\u0500\u0176\u0003\u0002\u0002\u0002\u0501\u0502\t,\u0002',
+  '\u0002\u0502\u0178\u0003\u0002\u0002\u0002\u0503\u0504\t\u0006\u0002',
+  '\u0002\u0504\u017a\u0003\u0002\u0002\u0002\u0505\u0506\t-\u0002\u0002',
+  '\u0506\u017c\u0003\u0002\u0002\u0002\u0507\u0508\t.\u0002\u0002\u0508',
+  '\u017e\u0003\u0002\u0002\u0002\u0509\u050a\t/\u0002\u0002\u050a\u0180',
+  '\u0003\u0002\u0002\u0002\u050b\u050c\t0\u0002\u0002\u050c\u0182\u0003',
+  '\u0002\u0002\u0002\u050d\u050e\t1\u0002\u0002\u050e\u0184\u0003\u0002',
+  '\u0002\u0002(\u0002\u03ee\u03f0\u03f2\u03fb\u03fd\u03ff\u0403\u040a',
+  '\u041e\u0426\u042d\u0430\u0436\u0439\u043d\u0441\u0445\u044b\u0452\u0457',
+  '\u045d\u0463\u0465\u0469\u046e\u0473\u047a\u0480\u0485\u0489\u048f\u0491',
+  '\u0499\u04a7\u04af\u04ba\u04bd\u0002'
+].join('')
+
+var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN)
+
+var decisionsToDFA = atn.decisionToState.map(function(ds, index) {
+  return new antlr4.dfa.DFA(ds, index)
+})
+
+function CypherLexer(input) {
+  antlr4.Lexer.call(this, input)
+  this._interp = new antlr4.atn.LexerATNSimulator(
+    this,
+    atn,
+    decisionsToDFA,
+    new antlr4.PredictionContextCache()
+  )
+  return this
+}
+
+CypherLexer.prototype = Object.create(antlr4.Lexer.prototype)
+CypherLexer.prototype.constructor = CypherLexer
+
+CypherLexer.EOF = antlr4.Token.EOF
+CypherLexer.T__0 = 1
+CypherLexer.T__1 = 2
+CypherLexer.T__2 = 3
+CypherLexer.T__3 = 4
+CypherLexer.T__4 = 5
+CypherLexer.T__5 = 6
+CypherLexer.T__6 = 7
+CypherLexer.T__7 = 8
+CypherLexer.T__8 = 9
+CypherLexer.T__9 = 10
+CypherLexer.T__10 = 11
+CypherLexer.T__11 = 12
+CypherLexer.T__12 = 13
+CypherLexer.T__13 = 14
+CypherLexer.T__14 = 15
+CypherLexer.T__15 = 16
+CypherLexer.T__16 = 17
+CypherLexer.T__17 = 18
+CypherLexer.T__18 = 19
+CypherLexer.T__19 = 20
+CypherLexer.T__20 = 21
+CypherLexer.T__21 = 22
+CypherLexer.T__22 = 23
+CypherLexer.T__23 = 24
+CypherLexer.T__24 = 25
+CypherLexer.T__25 = 26
+CypherLexer.T__26 = 27
+CypherLexer.T__27 = 28
+CypherLexer.T__28 = 29
+CypherLexer.T__29 = 30
+CypherLexer.T__30 = 31
+CypherLexer.T__31 = 32
+CypherLexer.T__32 = 33
+CypherLexer.T__33 = 34
+CypherLexer.T__34 = 35
+CypherLexer.T__35 = 36
+CypherLexer.T__36 = 37
+CypherLexer.T__37 = 38
+CypherLexer.T__38 = 39
+CypherLexer.T__39 = 40
+CypherLexer.T__40 = 41
+CypherLexer.T__41 = 42
+CypherLexer.T__42 = 43
+CypherLexer.T__43 = 44
+CypherLexer.T__44 = 45
+CypherLexer.T__45 = 46
+CypherLexer.T__46 = 47
+CypherLexer.T__47 = 48
+CypherLexer.T__48 = 49
+CypherLexer.T__49 = 50
+CypherLexer.T__50 = 51
+CypherLexer.T__51 = 52
+CypherLexer.T__52 = 53
+CypherLexer.CYPHER = 54
+CypherLexer.EXPLAIN = 55
+CypherLexer.PROFILE = 56
+CypherLexer.USING = 57
+CypherLexer.PERIODIC = 58
+CypherLexer.COMMIT = 59
+CypherLexer.UNION = 60
+CypherLexer.ALL = 61
+CypherLexer.CREATE = 62
+CypherLexer.DROP = 63
+CypherLexer.INDEX = 64
+CypherLexer.ON = 65
+CypherLexer.CONSTRAINT = 66
+CypherLexer.ASSERT = 67
+CypherLexer.IS = 68
+CypherLexer.UNIQUE = 69
+CypherLexer.EXISTS = 70
+CypherLexer.LOAD = 71
+CypherLexer.CSV = 72
+CypherLexer.WITH = 73
+CypherLexer.HEADERS = 74
+CypherLexer.FROM = 75
+CypherLexer.AS = 76
+CypherLexer.FIELDTERMINATOR = 77
+CypherLexer.OPTIONAL = 78
+CypherLexer.MATCH = 79
+CypherLexer.UNWIND = 80
+CypherLexer.MERGE = 81
+CypherLexer.SET = 82
+CypherLexer.DETACH = 83
+CypherLexer.DELETE = 84
+CypherLexer.REMOVE = 85
+CypherLexer.FOREACH = 86
+CypherLexer.IN = 87
+CypherLexer.DISTINCT = 88
+CypherLexer.RETURN = 89
+CypherLexer.ORDER = 90
+CypherLexer.BY = 91
+CypherLexer.L_SKIP = 92
+CypherLexer.LIMIT = 93
+CypherLexer.ASCENDING = 94
+CypherLexer.ASC = 95
+CypherLexer.DESCENDING = 96
+CypherLexer.DESC = 97
+CypherLexer.JOIN = 98
+CypherLexer.SCAN = 99
+CypherLexer.START = 100
+CypherLexer.NODE = 101
+CypherLexer.RELATIONSHIP = 102
+CypherLexer.REL = 103
+CypherLexer.WHERE = 104
+CypherLexer.SHORTESTPATH = 105
+CypherLexer.ALLSHORTESTPATHS = 106
+CypherLexer.OR = 107
+CypherLexer.XOR = 108
+CypherLexer.AND = 109
+CypherLexer.NOT = 110
+CypherLexer.STARTS = 111
+CypherLexer.ENDS = 112
+CypherLexer.CONTAINS = 113
+CypherLexer.NULL = 114
+CypherLexer.COUNT = 115
+CypherLexer.FILTER = 116
+CypherLexer.EXTRACT = 117
+CypherLexer.ANY = 118
+CypherLexer.NONE = 119
+CypherLexer.SINGLE = 120
+CypherLexer.TRUE = 121
+CypherLexer.FALSE = 122
+CypherLexer.REDUCE = 123
+CypherLexer.CASE = 124
+CypherLexer.ELSE = 125
+CypherLexer.END = 126
+CypherLexer.WHEN = 127
+CypherLexer.THEN = 128
+CypherLexer.CALL = 129
+CypherLexer.YIELD = 130
+CypherLexer.KEY = 131
+CypherLexer.StringLiteral = 132
+CypherLexer.UrlHex = 133
+CypherLexer.EscapedChar = 134
+CypherLexer.HexInteger = 135
+CypherLexer.DecimalInteger = 136
+CypherLexer.OctalInteger = 137
+CypherLexer.HexLetter = 138
+CypherLexer.HexDigit = 139
+CypherLexer.Digit = 140
+CypherLexer.NonZeroDigit = 141
+CypherLexer.NonZeroOctDigit = 142
+CypherLexer.OctDigit = 143
+CypherLexer.ZeroDigit = 144
+CypherLexer.ExponentDecimalReal = 145
+CypherLexer.RegularDecimalReal = 146
+CypherLexer.UnescapedSymbolicName = 147
+CypherLexer.IdentifierStart = 148
+CypherLexer.IdentifierPart = 149
+CypherLexer.EscapedSymbolicName = 150
+CypherLexer.SP = 151
+CypherLexer.WHITESPACE = 152
+CypherLexer.Comment = 153
+CypherLexer.ERROR_TOKEN = 154
+
+CypherLexer.prototype.channelNames = ['DEFAULT_TOKEN_CHANNEL', 'HIDDEN']
+
+CypherLexer.prototype.modeNames = ['DEFAULT_MODE']
+
+CypherLexer.prototype.literalNames = [
+  null,
+  "';'",
+  "':'",
+  "'-'",
+  "'=>'",
+  "'://'",
+  "'/'",
+  "'.'",
+  "'@'",
+  "'#'",
+  "'?'",
+  "'&'",
+  "'='",
+  "'+'",
+  "'{'",
+  "','",
+  "'}'",
+  "'['",
+  "']'",
+  "'('",
+  "')'",
+  "'+='",
+  "'|'",
+  "'*'",
+  "'..'",
+  "'%'",
+  "'^'",
+  "'=~'",
+  "'<>'",
+  "'!='",
+  "'<'",
+  "'>'",
+  "'<='",
+  "'>='",
+  "'$'",
+  "'\u27E8'",
+  "'\u3008'",
+  "'\uFE64'",
+  "'\uFF1C'",
+  "'\u27E9'",
+  "'\u3009'",
+  "'\uFE65'",
+  "'\uFF1E'",
+  "'\u00AD'",
+  "'\u2010'",
+  "'\u2011'",
+  "'\u2012'",
+  "'\u2013'",
+  "'\u2014'",
+  "'\u2015'",
+  "'\u2212'",
+  "'\uFE58'",
+  "'\uFE63'",
+  "'\uFF0D'",
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  "'0'"
+]
+
+CypherLexer.prototype.symbolicNames = [
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  'CYPHER',
+  'EXPLAIN',
+  'PROFILE',
+  'USING',
+  'PERIODIC',
+  'COMMIT',
+  'UNION',
+  'ALL',
+  'CREATE',
+  'DROP',
+  'INDEX',
+  'ON',
+  'CONSTRAINT',
+  'ASSERT',
+  'IS',
+  'UNIQUE',
+  'EXISTS',
+  'LOAD',
+  'CSV',
+  'WITH',
+  'HEADERS',
+  'FROM',
+  'AS',
+  'FIELDTERMINATOR',
+  'OPTIONAL',
+  'MATCH',
+  'UNWIND',
+  'MERGE',
+  'SET',
+  'DETACH',
+  'DELETE',
+  'REMOVE',
+  'FOREACH',
+  'IN',
+  'DISTINCT',
+  'RETURN',
+  'ORDER',
+  'BY',
+  'L_SKIP',
+  'LIMIT',
+  'ASCENDING',
+  'ASC',
+  'DESCENDING',
+  'DESC',
+  'JOIN',
+  'SCAN',
+  'START',
+  'NODE',
+  'RELATIONSHIP',
+  'REL',
+  'WHERE',
+  'SHORTESTPATH',
+  'ALLSHORTESTPATHS',
+  'OR',
+  'XOR',
+  'AND',
+  'NOT',
+  'STARTS',
+  'ENDS',
+  'CONTAINS',
+  'NULL',
+  'COUNT',
+  'FILTER',
+  'EXTRACT',
+  'ANY',
+  'NONE',
+  'SINGLE',
+  'TRUE',
+  'FALSE',
+  'REDUCE',
+  'CASE',
+  'ELSE',
+  'END',
+  'WHEN',
+  'THEN',
+  'CALL',
+  'YIELD',
+  'KEY',
+  'StringLiteral',
+  'UrlHex',
+  'EscapedChar',
+  'HexInteger',
+  'DecimalInteger',
+  'OctalInteger',
+  'HexLetter',
+  'HexDigit',
+  'Digit',
+  'NonZeroDigit',
+  'NonZeroOctDigit',
+  'OctDigit',
+  'ZeroDigit',
+  'ExponentDecimalReal',
+  'RegularDecimalReal',
+  'UnescapedSymbolicName',
+  'IdentifierStart',
+  'IdentifierPart',
+  'EscapedSymbolicName',
+  'SP',
+  'WHITESPACE',
+  'Comment',
+  'ERROR_TOKEN'
+]
+
+CypherLexer.prototype.ruleNames = [
+  'T__0',
+  'T__1',
+  'T__2',
+  'T__3',
+  'T__4',
+  'T__5',
+  'T__6',
+  'T__7',
+  'T__8',
+  'T__9',
+  'T__10',
+  'T__11',
+  'T__12',
+  'T__13',
+  'T__14',
+  'T__15',
+  'T__16',
+  'T__17',
+  'T__18',
+  'T__19',
+  'T__20',
+  'T__21',
+  'T__22',
+  'T__23',
+  'T__24',
+  'T__25',
+  'T__26',
+  'T__27',
+  'T__28',
+  'T__29',
+  'T__30',
+  'T__31',
+  'T__32',
+  'T__33',
+  'T__34',
+  'T__35',
+  'T__36',
+  'T__37',
+  'T__38',
+  'T__39',
+  'T__40',
+  'T__41',
+  'T__42',
+  'T__43',
+  'T__44',
+  'T__45',
+  'T__46',
+  'T__47',
+  'T__48',
+  'T__49',
+  'T__50',
+  'T__51',
+  'T__52',
+  'CYPHER',
+  'EXPLAIN',
+  'PROFILE',
+  'USING',
+  'PERIODIC',
+  'COMMIT',
+  'UNION',
+  'ALL',
+  'CREATE',
+  'DROP',
+  'INDEX',
+  'ON',
+  'CONSTRAINT',
+  'ASSERT',
+  'IS',
+  'UNIQUE',
+  'EXISTS',
+  'LOAD',
+  'CSV',
+  'WITH',
+  'HEADERS',
+  'FROM',
+  'AS',
+  'FIELDTERMINATOR',
+  'OPTIONAL',
+  'MATCH',
+  'UNWIND',
+  'MERGE',
+  'SET',
+  'DETACH',
+  'DELETE',
+  'REMOVE',
+  'FOREACH',
+  'IN',
+  'DISTINCT',
+  'RETURN',
+  'ORDER',
+  'BY',
+  'L_SKIP',
+  'LIMIT',
+  'ASCENDING',
+  'ASC',
+  'DESCENDING',
+  'DESC',
+  'JOIN',
+  'SCAN',
+  'START',
+  'NODE',
+  'RELATIONSHIP',
+  'REL',
+  'WHERE',
+  'SHORTESTPATH',
+  'ALLSHORTESTPATHS',
+  'OR',
+  'XOR',
+  'AND',
+  'NOT',
+  'STARTS',
+  'ENDS',
+  'CONTAINS',
+  'NULL',
+  'COUNT',
+  'FILTER',
+  'EXTRACT',
+  'ANY',
+  'NONE',
+  'SINGLE',
+  'TRUE',
+  'FALSE',
+  'REDUCE',
+  'CASE',
+  'ELSE',
+  'END',
+  'WHEN',
+  'THEN',
+  'CALL',
+  'YIELD',
+  'KEY',
+  'StringLiteral',
+  'UrlHex',
+  'EscapedChar',
+  'HexInteger',
+  'DecimalInteger',
+  'OctalInteger',
+  'HexLetter',
+  'HexDigit',
+  'Digit',
+  'NonZeroDigit',
+  'NonZeroOctDigit',
+  'OctDigit',
+  'ZeroDigit',
+  'ExponentDecimalReal',
+  'RegularDecimalReal',
+  'UnescapedSymbolicName',
+  'IdentifierStart',
+  'IdentifierPart',
+  'EscapedSymbolicName',
+  'SP',
+  'WHITESPACE',
+  'Comment',
+  'ERROR_TOKEN',
+  'FF',
+  'RS',
+  'ID_Continue',
+  'GS',
+  'FS',
+  'CR',
+  'Sc',
+  'SPACE',
+  'TAB',
+  'LF',
+  'VT',
+  'US',
+  'ID_Start',
+  'A',
+  'B',
+  'C',
+  'D',
+  'E',
+  'F',
+  'G',
+  'H',
+  'I',
+  'J',
+  'K',
+  'L',
+  'M',
+  'N',
+  'O',
+  'P',
+  'Q',
+  'R',
+  'S',
+  'T',
+  'U',
+  'V',
+  'W',
+  'X',
+  'Y',
+  'Z'
+]
+
+CypherLexer.prototype.grammarFileName = 'Cypher.g4'
+
+exports.CypherLexer = CypherLexer
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js b/src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js
new file mode 100644
index 00000000000..779d59910c2
--- /dev/null
+++ b/src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js
@@ -0,0 +1,1268 @@
+// Generated from cypher-editor-support/src/_generated.simple/Cypher.g4 by ANTLR 4.7
+// jshint ignore: start
+var antlr4 = require('antlr4/index')
+
+// This class defines a complete listener for a parse tree produced by CypherParser.
+function CypherListener() {
+  antlr4.tree.ParseTreeListener.call(this)
+  return this
+}
+
+CypherListener.prototype = Object.create(
+  antlr4.tree.ParseTreeListener.prototype
+)
+CypherListener.prototype.constructor = CypherListener
+
+// Enter a parse tree produced by CypherParser#raw.
+CypherListener.prototype.enterRaw = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#raw.
+CypherListener.prototype.exitRaw = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypher.
+CypherListener.prototype.enterCypher = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypher.
+CypherListener.prototype.exitCypher = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypherPart.
+CypherListener.prototype.enterCypherPart = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypherPart.
+CypherListener.prototype.exitCypherPart = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypherConsoleCommand.
+CypherListener.prototype.enterCypherConsoleCommand = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypherConsoleCommand.
+CypherListener.prototype.exitCypherConsoleCommand = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypherConsoleCommandName.
+CypherListener.prototype.enterCypherConsoleCommandName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypherConsoleCommandName.
+CypherListener.prototype.exitCypherConsoleCommandName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypherConsoleCommandParameters.
+CypherListener.prototype.enterCypherConsoleCommandParameters = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypherConsoleCommandParameters.
+CypherListener.prototype.exitCypherConsoleCommandParameters = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypherConsoleCommandParameter.
+CypherListener.prototype.enterCypherConsoleCommandParameter = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypherConsoleCommandParameter.
+CypherListener.prototype.exitCypherConsoleCommandParameter = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#arrowExpression.
+CypherListener.prototype.enterArrowExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#arrowExpression.
+CypherListener.prototype.exitArrowExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#url.
+CypherListener.prototype.enterUrl = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#url.
+CypherListener.prototype.exitUrl = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#uri.
+CypherListener.prototype.enterUri = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#uri.
+CypherListener.prototype.exitUri = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#scheme.
+CypherListener.prototype.enterScheme = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#scheme.
+CypherListener.prototype.exitScheme = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#host.
+CypherListener.prototype.enterHost = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#host.
+CypherListener.prototype.exitHost = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#hostname.
+CypherListener.prototype.enterHostname = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#hostname.
+CypherListener.prototype.exitHostname = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#hostnumber.
+CypherListener.prototype.enterHostnumber = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#hostnumber.
+CypherListener.prototype.exitHostnumber = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#port.
+CypherListener.prototype.enterPort = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#port.
+CypherListener.prototype.exitPort = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#path.
+CypherListener.prototype.enterPath = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#path.
+CypherListener.prototype.exitPath = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#user.
+CypherListener.prototype.enterUser = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#user.
+CypherListener.prototype.exitUser = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#login.
+CypherListener.prototype.enterLogin = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#login.
+CypherListener.prototype.exitLogin = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#password.
+CypherListener.prototype.enterPassword = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#password.
+CypherListener.prototype.exitPassword = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#frag.
+CypherListener.prototype.enterFrag = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#frag.
+CypherListener.prototype.exitFrag = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#urlQuery.
+CypherListener.prototype.enterUrlQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#urlQuery.
+CypherListener.prototype.exitUrlQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#search.
+CypherListener.prototype.enterSearch = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#search.
+CypherListener.prototype.exitSearch = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#searchparameter.
+CypherListener.prototype.enterSearchparameter = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#searchparameter.
+CypherListener.prototype.exitSearchparameter = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#string.
+CypherListener.prototype.enterString = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#string.
+CypherListener.prototype.exitString = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#urlDigits.
+CypherListener.prototype.enterUrlDigits = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#urlDigits.
+CypherListener.prototype.exitUrlDigits = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#json.
+CypherListener.prototype.enterJson = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#json.
+CypherListener.prototype.exitJson = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#obj.
+CypherListener.prototype.enterObj = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#obj.
+CypherListener.prototype.exitObj = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#pair.
+CypherListener.prototype.enterPair = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#pair.
+CypherListener.prototype.exitPair = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#array.
+CypherListener.prototype.enterArray = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#array.
+CypherListener.prototype.exitArray = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#value.
+CypherListener.prototype.enterValue = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#value.
+CypherListener.prototype.exitValue = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#keyValueLiteral.
+CypherListener.prototype.enterKeyValueLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#keyValueLiteral.
+CypherListener.prototype.exitKeyValueLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#commandPath.
+CypherListener.prototype.enterCommandPath = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#commandPath.
+CypherListener.prototype.exitCommandPath = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#subCommand.
+CypherListener.prototype.enterSubCommand = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#subCommand.
+CypherListener.prototype.exitSubCommand = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypherQuery.
+CypherListener.prototype.enterCypherQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypherQuery.
+CypherListener.prototype.exitCypherQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#queryOptions.
+CypherListener.prototype.enterQueryOptions = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#queryOptions.
+CypherListener.prototype.exitQueryOptions = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#anyCypherOption.
+CypherListener.prototype.enterAnyCypherOption = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#anyCypherOption.
+CypherListener.prototype.exitAnyCypherOption = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#cypherOption.
+CypherListener.prototype.enterCypherOption = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#cypherOption.
+CypherListener.prototype.exitCypherOption = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#versionNumber.
+CypherListener.prototype.enterVersionNumber = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#versionNumber.
+CypherListener.prototype.exitVersionNumber = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#explain.
+CypherListener.prototype.enterExplain = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#explain.
+CypherListener.prototype.exitExplain = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#profile.
+CypherListener.prototype.enterProfile = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#profile.
+CypherListener.prototype.exitProfile = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#configurationOption.
+CypherListener.prototype.enterConfigurationOption = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#configurationOption.
+CypherListener.prototype.exitConfigurationOption = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#statement.
+CypherListener.prototype.enterStatement = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#statement.
+CypherListener.prototype.exitStatement = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#query.
+CypherListener.prototype.enterQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#query.
+CypherListener.prototype.exitQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#regularQuery.
+CypherListener.prototype.enterRegularQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#regularQuery.
+CypherListener.prototype.exitRegularQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#bulkImportQuery.
+CypherListener.prototype.enterBulkImportQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#bulkImportQuery.
+CypherListener.prototype.exitBulkImportQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#singleQuery.
+CypherListener.prototype.enterSingleQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#singleQuery.
+CypherListener.prototype.exitSingleQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#periodicCommitHint.
+CypherListener.prototype.enterPeriodicCommitHint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#periodicCommitHint.
+CypherListener.prototype.exitPeriodicCommitHint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#loadCSVQuery.
+CypherListener.prototype.enterLoadCSVQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#loadCSVQuery.
+CypherListener.prototype.exitLoadCSVQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#union.
+CypherListener.prototype.enterUnion = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#union.
+CypherListener.prototype.exitUnion = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#clause.
+CypherListener.prototype.enterClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#clause.
+CypherListener.prototype.exitClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#command.
+CypherListener.prototype.enterCommand = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#command.
+CypherListener.prototype.exitCommand = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#createUniqueConstraint.
+CypherListener.prototype.enterCreateUniqueConstraint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#createUniqueConstraint.
+CypherListener.prototype.exitCreateUniqueConstraint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#createNodeKeyConstraint.
+CypherListener.prototype.enterCreateNodeKeyConstraint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#createNodeKeyConstraint.
+CypherListener.prototype.exitCreateNodeKeyConstraint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#createNodePropertyExistenceConstraint.
+CypherListener.prototype.enterCreateNodePropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Exit a parse tree produced by CypherParser#createNodePropertyExistenceConstraint.
+CypherListener.prototype.exitCreateNodePropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Enter a parse tree produced by CypherParser#createRelationshipPropertyExistenceConstraint.
+CypherListener.prototype.enterCreateRelationshipPropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Exit a parse tree produced by CypherParser#createRelationshipPropertyExistenceConstraint.
+CypherListener.prototype.exitCreateRelationshipPropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Enter a parse tree produced by CypherParser#createIndex.
+CypherListener.prototype.enterCreateIndex = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#createIndex.
+CypherListener.prototype.exitCreateIndex = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#dropUniqueConstraint.
+CypherListener.prototype.enterDropUniqueConstraint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#dropUniqueConstraint.
+CypherListener.prototype.exitDropUniqueConstraint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#dropNodeKeyConstraint.
+CypherListener.prototype.enterDropNodeKeyConstraint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#dropNodeKeyConstraint.
+CypherListener.prototype.exitDropNodeKeyConstraint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#dropNodePropertyExistenceConstraint.
+CypherListener.prototype.enterDropNodePropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Exit a parse tree produced by CypherParser#dropNodePropertyExistenceConstraint.
+CypherListener.prototype.exitDropNodePropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Enter a parse tree produced by CypherParser#dropRelationshipPropertyExistenceConstraint.
+CypherListener.prototype.enterDropRelationshipPropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Exit a parse tree produced by CypherParser#dropRelationshipPropertyExistenceConstraint.
+CypherListener.prototype.exitDropRelationshipPropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Enter a parse tree produced by CypherParser#dropIndex.
+CypherListener.prototype.enterDropIndex = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#dropIndex.
+CypherListener.prototype.exitDropIndex = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#index.
+CypherListener.prototype.enterIndex = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#index.
+CypherListener.prototype.exitIndex = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#uniqueConstraint.
+CypherListener.prototype.enterUniqueConstraint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#uniqueConstraint.
+CypherListener.prototype.exitUniqueConstraint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#nodeKeyConstraint.
+CypherListener.prototype.enterNodeKeyConstraint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#nodeKeyConstraint.
+CypherListener.prototype.exitNodeKeyConstraint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#nodePropertyExistenceConstraint.
+CypherListener.prototype.enterNodePropertyExistenceConstraint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#nodePropertyExistenceConstraint.
+CypherListener.prototype.exitNodePropertyExistenceConstraint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipPropertyExistenceConstraint.
+CypherListener.prototype.enterRelationshipPropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Exit a parse tree produced by CypherParser#relationshipPropertyExistenceConstraint.
+CypherListener.prototype.exitRelationshipPropertyExistenceConstraint = function(
+  ctx
+) {}
+
+// Enter a parse tree produced by CypherParser#relationshipPatternSyntax.
+CypherListener.prototype.enterRelationshipPatternSyntax = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipPatternSyntax.
+CypherListener.prototype.exitRelationshipPatternSyntax = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#loadCSVClause.
+CypherListener.prototype.enterLoadCSVClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#loadCSVClause.
+CypherListener.prototype.exitLoadCSVClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#matchClause.
+CypherListener.prototype.enterMatchClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#matchClause.
+CypherListener.prototype.exitMatchClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#unwindClause.
+CypherListener.prototype.enterUnwindClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#unwindClause.
+CypherListener.prototype.exitUnwindClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#mergeClause.
+CypherListener.prototype.enterMergeClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#mergeClause.
+CypherListener.prototype.exitMergeClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#mergeAction.
+CypherListener.prototype.enterMergeAction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#mergeAction.
+CypherListener.prototype.exitMergeAction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#createClause.
+CypherListener.prototype.enterCreateClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#createClause.
+CypherListener.prototype.exitCreateClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#createUniqueClause.
+CypherListener.prototype.enterCreateUniqueClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#createUniqueClause.
+CypherListener.prototype.exitCreateUniqueClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#setClause.
+CypherListener.prototype.enterSetClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#setClause.
+CypherListener.prototype.exitSetClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#setItem.
+CypherListener.prototype.enterSetItem = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#setItem.
+CypherListener.prototype.exitSetItem = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#deleteClause.
+CypherListener.prototype.enterDeleteClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#deleteClause.
+CypherListener.prototype.exitDeleteClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#removeClause.
+CypherListener.prototype.enterRemoveClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#removeClause.
+CypherListener.prototype.exitRemoveClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#removeItem.
+CypherListener.prototype.enterRemoveItem = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#removeItem.
+CypherListener.prototype.exitRemoveItem = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#foreachClause.
+CypherListener.prototype.enterForeachClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#foreachClause.
+CypherListener.prototype.exitForeachClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#withClause.
+CypherListener.prototype.enterWithClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#withClause.
+CypherListener.prototype.exitWithClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#returnClause.
+CypherListener.prototype.enterReturnClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#returnClause.
+CypherListener.prototype.exitReturnClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#returnBody.
+CypherListener.prototype.enterReturnBody = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#returnBody.
+CypherListener.prototype.exitReturnBody = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#func.
+CypherListener.prototype.enterFunc = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#func.
+CypherListener.prototype.exitFunc = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#returnItems.
+CypherListener.prototype.enterReturnItems = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#returnItems.
+CypherListener.prototype.exitReturnItems = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#returnItem.
+CypherListener.prototype.enterReturnItem = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#returnItem.
+CypherListener.prototype.exitReturnItem = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#call.
+CypherListener.prototype.enterCall = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#call.
+CypherListener.prototype.exitCall = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#procedureInvocation.
+CypherListener.prototype.enterProcedureInvocation = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#procedureInvocation.
+CypherListener.prototype.exitProcedureInvocation = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#procedureInvocationBody.
+CypherListener.prototype.enterProcedureInvocationBody = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#procedureInvocationBody.
+CypherListener.prototype.exitProcedureInvocationBody = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#procedureArguments.
+CypherListener.prototype.enterProcedureArguments = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#procedureArguments.
+CypherListener.prototype.exitProcedureArguments = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#procedureResults.
+CypherListener.prototype.enterProcedureResults = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#procedureResults.
+CypherListener.prototype.exitProcedureResults = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#procedureResult.
+CypherListener.prototype.enterProcedureResult = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#procedureResult.
+CypherListener.prototype.exitProcedureResult = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#aliasedProcedureResult.
+CypherListener.prototype.enterAliasedProcedureResult = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#aliasedProcedureResult.
+CypherListener.prototype.exitAliasedProcedureResult = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#simpleProcedureResult.
+CypherListener.prototype.enterSimpleProcedureResult = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#simpleProcedureResult.
+CypherListener.prototype.exitSimpleProcedureResult = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#procedureOutput.
+CypherListener.prototype.enterProcedureOutput = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#procedureOutput.
+CypherListener.prototype.exitProcedureOutput = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#order.
+CypherListener.prototype.enterOrder = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#order.
+CypherListener.prototype.exitOrder = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#skip.
+CypherListener.prototype.enterSkip = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#skip.
+CypherListener.prototype.exitSkip = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#limit.
+CypherListener.prototype.enterLimit = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#limit.
+CypherListener.prototype.exitLimit = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#sortItem.
+CypherListener.prototype.enterSortItem = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#sortItem.
+CypherListener.prototype.exitSortItem = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#hint.
+CypherListener.prototype.enterHint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#hint.
+CypherListener.prototype.exitHint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#startClause.
+CypherListener.prototype.enterStartClause = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#startClause.
+CypherListener.prototype.exitStartClause = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#startPoint.
+CypherListener.prototype.enterStartPoint = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#startPoint.
+CypherListener.prototype.exitStartPoint = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#lookup.
+CypherListener.prototype.enterLookup = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#lookup.
+CypherListener.prototype.exitLookup = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#nodeLookup.
+CypherListener.prototype.enterNodeLookup = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#nodeLookup.
+CypherListener.prototype.exitNodeLookup = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipLookup.
+CypherListener.prototype.enterRelationshipLookup = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipLookup.
+CypherListener.prototype.exitRelationshipLookup = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#identifiedIndexLookup.
+CypherListener.prototype.enterIdentifiedIndexLookup = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#identifiedIndexLookup.
+CypherListener.prototype.exitIdentifiedIndexLookup = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#indexQuery.
+CypherListener.prototype.enterIndexQuery = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#indexQuery.
+CypherListener.prototype.exitIndexQuery = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#idLookup.
+CypherListener.prototype.enterIdLookup = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#idLookup.
+CypherListener.prototype.exitIdLookup = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#literalIds.
+CypherListener.prototype.enterLiteralIds = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#literalIds.
+CypherListener.prototype.exitLiteralIds = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#where.
+CypherListener.prototype.enterWhere = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#where.
+CypherListener.prototype.exitWhere = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#pattern.
+CypherListener.prototype.enterPattern = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#pattern.
+CypherListener.prototype.exitPattern = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#patternPart.
+CypherListener.prototype.enterPatternPart = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#patternPart.
+CypherListener.prototype.exitPatternPart = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#anonymousPatternPart.
+CypherListener.prototype.enterAnonymousPatternPart = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#anonymousPatternPart.
+CypherListener.prototype.exitAnonymousPatternPart = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#patternElement.
+CypherListener.prototype.enterPatternElement = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#patternElement.
+CypherListener.prototype.exitPatternElement = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#nodePattern.
+CypherListener.prototype.enterNodePattern = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#nodePattern.
+CypherListener.prototype.exitNodePattern = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#patternElementChain.
+CypherListener.prototype.enterPatternElementChain = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#patternElementChain.
+CypherListener.prototype.exitPatternElementChain = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipPattern.
+CypherListener.prototype.enterRelationshipPattern = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipPattern.
+CypherListener.prototype.exitRelationshipPattern = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipPatternStart.
+CypherListener.prototype.enterRelationshipPatternStart = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipPatternStart.
+CypherListener.prototype.exitRelationshipPatternStart = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipPatternEnd.
+CypherListener.prototype.enterRelationshipPatternEnd = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipPatternEnd.
+CypherListener.prototype.exitRelationshipPatternEnd = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipDetail.
+CypherListener.prototype.enterRelationshipDetail = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipDetail.
+CypherListener.prototype.exitRelationshipDetail = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#properties.
+CypherListener.prototype.enterProperties = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#properties.
+CypherListener.prototype.exitProperties = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relType.
+CypherListener.prototype.enterRelType = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relType.
+CypherListener.prototype.exitRelType = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipTypes.
+CypherListener.prototype.enterRelationshipTypes = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipTypes.
+CypherListener.prototype.exitRelationshipTypes = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipType.
+CypherListener.prototype.enterRelationshipType = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipType.
+CypherListener.prototype.exitRelationshipType = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipTypeOptionalColon.
+CypherListener.prototype.enterRelationshipTypeOptionalColon = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipTypeOptionalColon.
+CypherListener.prototype.exitRelationshipTypeOptionalColon = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#nodeLabels.
+CypherListener.prototype.enterNodeLabels = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#nodeLabels.
+CypherListener.prototype.exitNodeLabels = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#nodeLabel.
+CypherListener.prototype.enterNodeLabel = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#nodeLabel.
+CypherListener.prototype.exitNodeLabel = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#rangeLiteral.
+CypherListener.prototype.enterRangeLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#rangeLiteral.
+CypherListener.prototype.exitRangeLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#labelName.
+CypherListener.prototype.enterLabelName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#labelName.
+CypherListener.prototype.exitLabelName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relTypeName.
+CypherListener.prototype.enterRelTypeName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relTypeName.
+CypherListener.prototype.exitRelTypeName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#expression.
+CypherListener.prototype.enterExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#expression.
+CypherListener.prototype.exitExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#orExpression.
+CypherListener.prototype.enterOrExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#orExpression.
+CypherListener.prototype.exitOrExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#xorExpression.
+CypherListener.prototype.enterXorExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#xorExpression.
+CypherListener.prototype.exitXorExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#andExpression.
+CypherListener.prototype.enterAndExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#andExpression.
+CypherListener.prototype.exitAndExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#notExpression.
+CypherListener.prototype.enterNotExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#notExpression.
+CypherListener.prototype.exitNotExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#comparisonExpression.
+CypherListener.prototype.enterComparisonExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#comparisonExpression.
+CypherListener.prototype.exitComparisonExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#addOrSubtractExpression.
+CypherListener.prototype.enterAddOrSubtractExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#addOrSubtractExpression.
+CypherListener.prototype.exitAddOrSubtractExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#multiplyDivideModuloExpression.
+CypherListener.prototype.enterMultiplyDivideModuloExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#multiplyDivideModuloExpression.
+CypherListener.prototype.exitMultiplyDivideModuloExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#powerOfExpression.
+CypherListener.prototype.enterPowerOfExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#powerOfExpression.
+CypherListener.prototype.exitPowerOfExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#unaryAddOrSubtractExpression.
+CypherListener.prototype.enterUnaryAddOrSubtractExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#unaryAddOrSubtractExpression.
+CypherListener.prototype.exitUnaryAddOrSubtractExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#stringListNullOperatorExpression.
+CypherListener.prototype.enterStringListNullOperatorExpression = function(
+  ctx
+) {}
+
+// Exit a parse tree produced by CypherParser#stringListNullOperatorExpression.
+CypherListener.prototype.exitStringListNullOperatorExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#propertyOrLabelsExpression.
+CypherListener.prototype.enterPropertyOrLabelsExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#propertyOrLabelsExpression.
+CypherListener.prototype.exitPropertyOrLabelsExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#filterFunction.
+CypherListener.prototype.enterFilterFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#filterFunction.
+CypherListener.prototype.exitFilterFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#filterFunctionName.
+CypherListener.prototype.enterFilterFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#filterFunctionName.
+CypherListener.prototype.exitFilterFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#existsFunction.
+CypherListener.prototype.enterExistsFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#existsFunction.
+CypherListener.prototype.exitExistsFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#existsFunctionName.
+CypherListener.prototype.enterExistsFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#existsFunctionName.
+CypherListener.prototype.exitExistsFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#allFunction.
+CypherListener.prototype.enterAllFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#allFunction.
+CypherListener.prototype.exitAllFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#allFunctionName.
+CypherListener.prototype.enterAllFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#allFunctionName.
+CypherListener.prototype.exitAllFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#anyFunction.
+CypherListener.prototype.enterAnyFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#anyFunction.
+CypherListener.prototype.exitAnyFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#anyFunctionName.
+CypherListener.prototype.enterAnyFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#anyFunctionName.
+CypherListener.prototype.exitAnyFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#noneFunction.
+CypherListener.prototype.enterNoneFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#noneFunction.
+CypherListener.prototype.exitNoneFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#noneFunctionName.
+CypherListener.prototype.enterNoneFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#noneFunctionName.
+CypherListener.prototype.exitNoneFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#singleFunction.
+CypherListener.prototype.enterSingleFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#singleFunction.
+CypherListener.prototype.exitSingleFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#singleFunctionName.
+CypherListener.prototype.enterSingleFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#singleFunctionName.
+CypherListener.prototype.exitSingleFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#extractFunction.
+CypherListener.prototype.enterExtractFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#extractFunction.
+CypherListener.prototype.exitExtractFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#extractFunctionName.
+CypherListener.prototype.enterExtractFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#extractFunctionName.
+CypherListener.prototype.exitExtractFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#reduceFunction.
+CypherListener.prototype.enterReduceFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#reduceFunction.
+CypherListener.prototype.exitReduceFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#reduceFunctionName.
+CypherListener.prototype.enterReduceFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#reduceFunctionName.
+CypherListener.prototype.exitReduceFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#shortestPathPatternFunction.
+CypherListener.prototype.enterShortestPathPatternFunction = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#shortestPathPatternFunction.
+CypherListener.prototype.exitShortestPathPatternFunction = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#shortestPathFunctionName.
+CypherListener.prototype.enterShortestPathFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#shortestPathFunctionName.
+CypherListener.prototype.exitShortestPathFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#allShortestPathFunctionName.
+CypherListener.prototype.enterAllShortestPathFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#allShortestPathFunctionName.
+CypherListener.prototype.exitAllShortestPathFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#atom.
+CypherListener.prototype.enterAtom = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#atom.
+CypherListener.prototype.exitAtom = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#literal.
+CypherListener.prototype.enterLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#literal.
+CypherListener.prototype.exitLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#stringLiteral.
+CypherListener.prototype.enterStringLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#stringLiteral.
+CypherListener.prototype.exitStringLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#booleanLiteral.
+CypherListener.prototype.enterBooleanLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#booleanLiteral.
+CypherListener.prototype.exitBooleanLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#listLiteral.
+CypherListener.prototype.enterListLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#listLiteral.
+CypherListener.prototype.exitListLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#partialComparisonExpression.
+CypherListener.prototype.enterPartialComparisonExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#partialComparisonExpression.
+CypherListener.prototype.exitPartialComparisonExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#parenthesizedExpression.
+CypherListener.prototype.enterParenthesizedExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#parenthesizedExpression.
+CypherListener.prototype.exitParenthesizedExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#relationshipsPattern.
+CypherListener.prototype.enterRelationshipsPattern = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#relationshipsPattern.
+CypherListener.prototype.exitRelationshipsPattern = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#filterExpression.
+CypherListener.prototype.enterFilterExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#filterExpression.
+CypherListener.prototype.exitFilterExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#idInColl.
+CypherListener.prototype.enterIdInColl = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#idInColl.
+CypherListener.prototype.exitIdInColl = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#functionInvocation.
+CypherListener.prototype.enterFunctionInvocation = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#functionInvocation.
+CypherListener.prototype.exitFunctionInvocation = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#functionInvocationBody.
+CypherListener.prototype.enterFunctionInvocationBody = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#functionInvocationBody.
+CypherListener.prototype.exitFunctionInvocationBody = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#functionName.
+CypherListener.prototype.enterFunctionName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#functionName.
+CypherListener.prototype.exitFunctionName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#procedureName.
+CypherListener.prototype.enterProcedureName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#procedureName.
+CypherListener.prototype.exitProcedureName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#listComprehension.
+CypherListener.prototype.enterListComprehension = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#listComprehension.
+CypherListener.prototype.exitListComprehension = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#patternComprehension.
+CypherListener.prototype.enterPatternComprehension = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#patternComprehension.
+CypherListener.prototype.exitPatternComprehension = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#propertyLookup.
+CypherListener.prototype.enterPropertyLookup = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#propertyLookup.
+CypherListener.prototype.exitPropertyLookup = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#caseExpression.
+CypherListener.prototype.enterCaseExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#caseExpression.
+CypherListener.prototype.exitCaseExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#caseAlternatives.
+CypherListener.prototype.enterCaseAlternatives = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#caseAlternatives.
+CypherListener.prototype.exitCaseAlternatives = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#variable.
+CypherListener.prototype.enterVariable = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#variable.
+CypherListener.prototype.exitVariable = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#numberLiteral.
+CypherListener.prototype.enterNumberLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#numberLiteral.
+CypherListener.prototype.exitNumberLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#mapLiteral.
+CypherListener.prototype.enterMapLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#mapLiteral.
+CypherListener.prototype.exitMapLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#mapProjection.
+CypherListener.prototype.enterMapProjection = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#mapProjection.
+CypherListener.prototype.exitMapProjection = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#mapProjectionVariants.
+CypherListener.prototype.enterMapProjectionVariants = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#mapProjectionVariants.
+CypherListener.prototype.exitMapProjectionVariants = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#literalEntry.
+CypherListener.prototype.enterLiteralEntry = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#literalEntry.
+CypherListener.prototype.exitLiteralEntry = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#propertySelector.
+CypherListener.prototype.enterPropertySelector = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#propertySelector.
+CypherListener.prototype.exitPropertySelector = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#variableSelector.
+CypherListener.prototype.enterVariableSelector = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#variableSelector.
+CypherListener.prototype.exitVariableSelector = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#allPropertiesSelector.
+CypherListener.prototype.enterAllPropertiesSelector = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#allPropertiesSelector.
+CypherListener.prototype.exitAllPropertiesSelector = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#parameter.
+CypherListener.prototype.enterParameter = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#parameter.
+CypherListener.prototype.exitParameter = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#legacyParameter.
+CypherListener.prototype.enterLegacyParameter = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#legacyParameter.
+CypherListener.prototype.exitLegacyParameter = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#newParameter.
+CypherListener.prototype.enterNewParameter = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#newParameter.
+CypherListener.prototype.exitNewParameter = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#parameterName.
+CypherListener.prototype.enterParameterName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#parameterName.
+CypherListener.prototype.exitParameterName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#propertyExpressions.
+CypherListener.prototype.enterPropertyExpressions = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#propertyExpressions.
+CypherListener.prototype.exitPropertyExpressions = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#propertyExpression.
+CypherListener.prototype.enterPropertyExpression = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#propertyExpression.
+CypherListener.prototype.exitPropertyExpression = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#propertyKeys.
+CypherListener.prototype.enterPropertyKeys = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#propertyKeys.
+CypherListener.prototype.exitPropertyKeys = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#propertyKeyName.
+CypherListener.prototype.enterPropertyKeyName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#propertyKeyName.
+CypherListener.prototype.exitPropertyKeyName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#integerLiteral.
+CypherListener.prototype.enterIntegerLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#integerLiteral.
+CypherListener.prototype.exitIntegerLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#doubleLiteral.
+CypherListener.prototype.enterDoubleLiteral = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#doubleLiteral.
+CypherListener.prototype.exitDoubleLiteral = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#namespace.
+CypherListener.prototype.enterNamespace = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#namespace.
+CypherListener.prototype.exitNamespace = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#leftArrowHead.
+CypherListener.prototype.enterLeftArrowHead = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#leftArrowHead.
+CypherListener.prototype.exitLeftArrowHead = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#rightArrowHead.
+CypherListener.prototype.enterRightArrowHead = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#rightArrowHead.
+CypherListener.prototype.exitRightArrowHead = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#dash.
+CypherListener.prototype.enterDash = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#dash.
+CypherListener.prototype.exitDash = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#symbolicName.
+CypherListener.prototype.enterSymbolicName = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#symbolicName.
+CypherListener.prototype.exitSymbolicName = function(ctx) {}
+
+// Enter a parse tree produced by CypherParser#keyword.
+CypherListener.prototype.enterKeyword = function(ctx) {}
+
+// Exit a parse tree produced by CypherParser#keyword.
+CypherListener.prototype.exitKeyword = function(ctx) {}
+
+exports.CypherListener = CypherListener
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js b/src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js
new file mode 100644
index 00000000000..de867f0f7cc
--- /dev/null
+++ b/src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js
@@ -0,0 +1,24555 @@
+// Generated from cypher-editor-support/src/_generated/Cypher.g4 by ANTLR 4.7
+// jshint ignore: start
+var antlr4 = require('antlr4')
+var CypherListener = require('./CypherListener').CypherListener
+var grammarFileName = 'Cypher.g4'
+
+var serializedATN = [
+  '\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964',
+  '\u0003\u009c\u0a7b\u0004\u0002\t\u0002\u0004\u0003\t\u0003\u0004\u0004',
+  '\t\u0004\u0004\u0005\t\u0005\u0004\u0006\t\u0006\u0004\u0007\t\u0007',
+  '\u0004\b\t\b\u0004\t\t\t\u0004\n\t\n\u0004\u000b\t\u000b\u0004\f\t\f',
+  '\u0004\r\t\r\u0004\u000e\t\u000e\u0004\u000f\t\u000f\u0004\u0010\t\u0010',
+  '\u0004\u0011\t\u0011\u0004\u0012\t\u0012\u0004\u0013\t\u0013\u0004\u0014',
+  '\t\u0014\u0004\u0015\t\u0015\u0004\u0016\t\u0016\u0004\u0017\t\u0017',
+  '\u0004\u0018\t\u0018\u0004\u0019\t\u0019\u0004\u001a\t\u001a\u0004\u001b',
+  '\t\u001b\u0004\u001c\t\u001c\u0004\u001d\t\u001d\u0004\u001e\t\u001e',
+  '\u0004\u001f\t\u001f\u0004 \t \u0004!\t!\u0004"\t"\u0004#\t#\u0004',
+  "$\t$\u0004%\t%\u0004&\t&\u0004'\t'\u0004(\t(\u0004)\t)\u0004*\t*\u0004",
+  '+\t+\u0004,\t,\u0004-\t-\u0004.\t.\u0004/\t/\u00040\t0\u00041\t1\u0004',
+  '2\t2\u00043\t3\u00044\t4\u00045\t5\u00046\t6\u00047\t7\u00048\t8\u0004',
+  '9\t9\u0004:\t:\u0004;\t;\u0004<\t<\u0004=\t=\u0004>\t>\u0004?\t?\u0004',
+  '@\t@\u0004A\tA\u0004B\tB\u0004C\tC\u0004D\tD\u0004E\tE\u0004F\tF\u0004',
+  'G\tG\u0004H\tH\u0004I\tI\u0004J\tJ\u0004K\tK\u0004L\tL\u0004M\tM\u0004',
+  'N\tN\u0004O\tO\u0004P\tP\u0004Q\tQ\u0004R\tR\u0004S\tS\u0004T\tT\u0004',
+  'U\tU\u0004V\tV\u0004W\tW\u0004X\tX\u0004Y\tY\u0004Z\tZ\u0004[\t[\u0004',
+  '\\\t\\\u0004]\t]\u0004^\t^\u0004_\t_\u0004`\t`\u0004a\ta\u0004b\tb\u0004',
+  'c\tc\u0004d\td\u0004e\te\u0004f\tf\u0004g\tg\u0004h\th\u0004i\ti\u0004',
+  'j\tj\u0004k\tk\u0004l\tl\u0004m\tm\u0004n\tn\u0004o\to\u0004p\tp\u0004',
+  'q\tq\u0004r\tr\u0004s\ts\u0004t\tt\u0004u\tu\u0004v\tv\u0004w\tw\u0004',
+  'x\tx\u0004y\ty\u0004z\tz\u0004{\t{\u0004|\t|\u0004}\t}\u0004~\t~\u0004',
+  '\u007f\t\u007f\u0004\u0080\t\u0080\u0004\u0081\t\u0081\u0004\u0082\t',
+  '\u0082\u0004\u0083\t\u0083\u0004\u0084\t\u0084\u0004\u0085\t\u0085\u0004',
+  '\u0086\t\u0086\u0004\u0087\t\u0087\u0004\u0088\t\u0088\u0004\u0089\t',
+  '\u0089\u0004\u008a\t\u008a\u0004\u008b\t\u008b\u0004\u008c\t\u008c\u0004',
+  '\u008d\t\u008d\u0004\u008e\t\u008e\u0004\u008f\t\u008f\u0004\u0090\t',
+  '\u0090\u0004\u0091\t\u0091\u0004\u0092\t\u0092\u0004\u0093\t\u0093\u0004',
+  '\u0094\t\u0094\u0004\u0095\t\u0095\u0004\u0096\t\u0096\u0004\u0097\t',
+  '\u0097\u0004\u0098\t\u0098\u0004\u0099\t\u0099\u0004\u009a\t\u009a\u0004',
+  '\u009b\t\u009b\u0004\u009c\t\u009c\u0004\u009d\t\u009d\u0004\u009e\t',
+  '\u009e\u0004\u009f\t\u009f\u0004\u00a0\t\u00a0\u0004\u00a1\t\u00a1\u0004',
+  '\u00a2\t\u00a2\u0004\u00a3\t\u00a3\u0004\u00a4\t\u00a4\u0004\u00a5\t',
+  '\u00a5\u0004\u00a6\t\u00a6\u0004\u00a7\t\u00a7\u0004\u00a8\t\u00a8\u0004',
+  '\u00a9\t\u00a9\u0004\u00aa\t\u00aa\u0004\u00ab\t\u00ab\u0004\u00ac\t',
+  '\u00ac\u0004\u00ad\t\u00ad\u0004\u00ae\t\u00ae\u0004\u00af\t\u00af\u0004',
+  '\u00b0\t\u00b0\u0004\u00b1\t\u00b1\u0004\u00b2\t\u00b2\u0004\u00b3\t',
+  '\u00b3\u0004\u00b4\t\u00b4\u0004\u00b5\t\u00b5\u0004\u00b6\t\u00b6\u0004',
+  '\u00b7\t\u00b7\u0004\u00b8\t\u00b8\u0004\u00b9\t\u00b9\u0004\u00ba\t',
+  '\u00ba\u0004\u00bb\t\u00bb\u0004\u00bc\t\u00bc\u0004\u00bd\t\u00bd\u0004',
+  '\u00be\t\u00be\u0004\u00bf\t\u00bf\u0004\u00c0\t\u00c0\u0004\u00c1\t',
+  '\u00c1\u0004\u00c2\t\u00c2\u0004\u00c3\t\u00c3\u0004\u00c4\t\u00c4\u0004',
+  '\u00c5\t\u00c5\u0004\u00c6\t\u00c6\u0004\u00c7\t\u00c7\u0004\u00c8\t',
+  '\u00c8\u0004\u00c9\t\u00c9\u0004\u00ca\t\u00ca\u0004\u00cb\t\u00cb\u0004',
+  '\u00cc\t\u00cc\u0003\u0002\u0003\u0002\u0003\u0002\u0007\u0002\u019c',
+  '\n\u0002\f\u0002\u000e\u0002\u019f\u000b\u0002\u0003\u0002\u0005\u0002',
+  '\u01a2\n\u0002\u0003\u0002\u0003\u0002\u0003\u0003\u0005\u0003\u01a7',
+  '\n\u0003\u0003\u0003\u0003\u0003\u0005\u0003\u01ab\n\u0003\u0003\u0003',
+  '\u0005\u0003\u01ae\n\u0003\u0003\u0004\u0003\u0004\u0003\u0004\u0005',
+  '\u0004\u01b3\n\u0004\u0003\u0005\u0003\u0005\u0003\u0005\u0003\u0005',
+  '\u0007\u0005\u01b9\n\u0005\f\u0005\u000e\u0005\u01bc\u000b\u0005\u0003',
+  '\u0006\u0003\u0006\u0003\u0006\u0007\u0006\u01c1\n\u0006\f\u0006\u000e',
+  '\u0006\u01c4\u000b\u0006\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007',
+  '\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007',
+  '\u0005\u0007\u01d0\n\u0007\u0003\b\u0003\b\u0005\b\u01d4\n\b\u0003\b',
+  '\u0003\b\u0005\b\u01d8\n\b\u0003\b\u0003\b\u0003\t\u0003\t\u0003\n\u0003',
+  '\n\u0003\n\u0005\n\u01e1\n\n\u0003\n\u0003\n\u0003\n\u0005\n\u01e6\n',
+  '\n\u0003\n\u0003\n\u0005\n\u01ea\n\n\u0003\n\u0005\n\u01ed\n\n\u0003',
+  '\n\u0005\n\u01f0\n\n\u0003\u000b\u0003\u000b\u0003\f\u0005\f\u01f5\n',
+  '\f\u0003\f\u0003\f\u0005\f\u01f9\n\f\u0003\r\u0003\r\u0003\r\u0007\r',
+  '\u01fe\n\r\f\r\u000e\r\u0201\u000b\r\u0003\u000e\u0003\u000e\u0003\u000e',
+  '\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000f',
+  '\u0003\u000f\u0003\u0010\u0003\u0010\u0003\u0010\u0007\u0010\u0210\n',
+  '\u0010\f\u0010\u000e\u0010\u0213\u000b\u0010\u0003\u0011\u0003\u0011',
+  '\u0003\u0012\u0003\u0012\u0003\u0012\u0003\u0012\u0003\u0012\u0003\u0013',
+  '\u0003\u0013\u0003\u0014\u0003\u0014\u0003\u0014\u0003\u0015\u0003\u0015',
+  '\u0003\u0015\u0003\u0016\u0003\u0016\u0003\u0016\u0007\u0016\u0227\n',
+  '\u0016\f\u0016\u000e\u0016\u022a\u000b\u0016\u0003\u0017\u0003\u0017',
+  '\u0003\u0017\u0003\u0017\u0003\u0017\u0005\u0017\u0231\n\u0017\u0005',
+  '\u0017\u0233\n\u0017\u0003\u0018\u0003\u0018\u0005\u0018\u0237\n\u0018',
+  '\u0003\u0018\u0007\u0018\u023a\n\u0018\f\u0018\u000e\u0018\u023d\u000b',
+  '\u0018\u0003\u0019\u0006\u0019\u0240\n\u0019\r\u0019\u000e\u0019\u0241',
+  '\u0003\u001a\u0003\u001a\u0003\u001b\u0003\u001b\u0005\u001b\u0248\n',
+  '\u001b\u0003\u001b\u0003\u001b\u0005\u001b\u024c\n\u001b\u0003\u001b',
+  '\u0003\u001b\u0005\u001b\u0250\n\u001b\u0003\u001b\u0003\u001b\u0005',
+  '\u001b\u0254\n\u001b\u0007\u001b\u0256\n\u001b\f\u001b\u000e\u001b\u0259',
+  '\u000b\u001b\u0003\u001b\u0003\u001b\u0003\u001b\u0003\u001b\u0005\u001b',
+  '\u025f\n\u001b\u0003\u001b\u0005\u001b\u0262\n\u001b\u0003\u001c\u0003',
+  '\u001c\u0005\u001c\u0266\n\u001c\u0003\u001c\u0003\u001c\u0005\u001c',
+  '\u026a\n\u001c\u0003\u001c\u0003\u001c\u0003\u001d\u0003\u001d\u0005',
+  '\u001d\u0270\n\u001d\u0003\u001d\u0003\u001d\u0005\u001d\u0274\n\u001d',
+  '\u0003\u001d\u0003\u001d\u0005\u001d\u0278\n\u001d\u0003\u001d\u0003',
+  '\u001d\u0005\u001d\u027c\n\u001d\u0007\u001d\u027e\n\u001d\f\u001d\u000e',
+  '\u001d\u0281\u000b\u001d\u0003\u001d\u0003\u001d\u0003\u001d\u0003\u001d',
+  '\u0005\u001d\u0287\n\u001d\u0003\u001d\u0005\u001d\u028a\n\u001d\u0003',
+  '\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0005',
+  '\u001e\u0292\n\u001e\u0003\u001f\u0003\u001f\u0003\u001f\u0003\u001f',
+  '\u0003\u001f\u0003\u001f\u0003\u001f\u0005\u001f\u029b\n\u001f\u0003',
+  ' \u0003 \u0003 \u0005 \u02a0\n \u0006 \u02a2\n \r \u000e \u02a3\u0003',
+  ' \u0005 \u02a7\n \u0003!\u0003!\u0003!\u0007!\u02ac\n!\f!\u000e!\u02af',
+  '\u000b!\u0003"\u0003"\u0003"\u0003#\u0003#\u0005#\u02b6\n#\u0007',
+  '#\u02b8\n#\f#\u000e#\u02bb\u000b#\u0003$\u0003$\u0003$\u0005$\u02c0',
+  '\n$\u0003%\u0003%\u0003%\u0005%\u02c5\n%\u0003%\u0003%\u0007%\u02c9',
+  "\n%\f%\u000e%\u02cc\u000b%\u0003&\u0003&\u0003'\u0003'\u0003(\u0003",
+  '(\u0003)\u0003)\u0005)\u02d6\n)\u0003)\u0003)\u0005)\u02da\n)\u0003',
+  ')\u0003)\u0003*\u0003*\u0005*\u02e0\n*\u0003+\u0003+\u0005+\u02e4\n',
+  '+\u0003,\u0003,\u0005,\u02e8\n,\u0003,\u0007,\u02eb\n,\f,\u000e,\u02ee',
+  '\u000b,\u0003-\u0003-\u0005-\u02f2\n-\u0003-\u0003-\u0003.\u0003.\u0005',
+  '.\u02f8\n.\u0003.\u0007.\u02fb\n.\f.\u000e.\u02fe\u000b.\u0003/\u0003',
+  '/\u0003/\u0003/\u0003/\u0003/\u0003/\u0005/\u0307\n/\u00030\u00030\u0005',
+  '0\u030b\n0\u00030\u00070\u030e\n0\f0\u000e0\u0311\u000b0\u00031\u0003',
+  '1\u00031\u00031\u00051\u0317\n1\u00031\u00031\u00031\u00051\u031c\n',
+  '1\u00031\u00051\u031f\n1\u00032\u00032\u00032\u00032\u00032\u00032\u0003',
+  '2\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00052\u032f\n2\u0003',
+  '3\u00033\u00033\u00033\u00033\u00033\u00033\u00033\u00033\u00033\u0005',
+  '3\u033b\n3\u00034\u00034\u00034\u00034\u00035\u00035\u00035\u00035\u0003',
+  '6\u00036\u00036\u00036\u00037\u00037\u00037\u00037\u00038\u00038\u0003',
+  '8\u00038\u00039\u00039\u00039\u00039\u0003:\u0003:\u0003:\u0003:\u0003',
+  ';\u0003;\u0003;\u0003;\u0003<\u0003<\u0003<\u0003<\u0003=\u0003=\u0003',
+  '=\u0003=\u0003>\u0003>\u0003>\u0003>\u0005>\u0369\n>\u0003>\u0003>\u0005',
+  '>\u036d\n>\u0003>\u0003>\u0005>\u0371\n>\u0003>\u0003>\u0005>\u0375',
+  '\n>\u0003>\u0003>\u0003?\u0003?\u0003?\u0003?\u0005?\u037d\n?\u0003',
+  '?\u0003?\u0005?\u0381\n?\u0003?\u0003?\u0003?\u0005?\u0386\n?\u0003',
+  '?\u0003?\u0005?\u038a\n?\u0003?\u0003?\u0003?\u0003?\u0003?\u0003?\u0003',
+  '?\u0003?\u0003@\u0003@\u0003@\u0003@\u0005@\u0398\n@\u0003@\u0003@\u0005',
+  '@\u039c\n@\u0003@\u0003@\u0003@\u0005@\u03a1\n@\u0003@\u0003@\u0005',
+  '@\u03a5\n@\u0003@\u0003@\u0003@\u0003@\u0005@\u03ab\n@\u0003@\u0003',
+  '@\u0005@\u03af\n@\u0003@\u0003@\u0003@\u0003@\u0003@\u0003@\u0003@\u0003',
+  '@\u0003A\u0003A\u0003A\u0003A\u0005A\u03bd\nA\u0003A\u0003A\u0003A\u0003',
+  'A\u0003A\u0005A\u03c4\nA\u0003A\u0003A\u0003A\u0003A\u0005A\u03ca\n',
+  'A\u0003A\u0003A\u0003A\u0003A\u0003B\u0003B\u0003B\u0003B\u0005B\u03d4',
+  '\nB\u0003B\u0003B\u0005B\u03d8\nB\u0003B\u0003B\u0003B\u0003B\u0005',
+  'B\u03de\nB\u0003B\u0003B\u0003B\u0003B\u0003C\u0003C\u0005C\u03e6\n',
+  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0005',
+  'C\u03f1\nC\u0003C\u0003C\u0003C\u0003C\u0005C\u03f7\nC\u0003C\u0003',
+  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0005C\u0403',
+  '\nC\u0003C\u0003C\u0003C\u0003C\u0005C\u0409\nC\u0003C\u0003C\u0003',
+  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0005C\u0415\nC\u0003',
+  'C\u0003C\u0005C\u0419\nC\u0003D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003',
+  'D\u0003D\u0005D\u0423\nD\u0003D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003',
+  'D\u0003D\u0003D\u0003D\u0003D\u0005D\u0430\nD\u0003E\u0003E\u0005E\u0434',
+  '\nE\u0003E\u0003E\u0005E\u0438\nE\u0003E\u0003E\u0007E\u043c\nE\fE\u000e',
+  'E\u043f\u000bE\u0003E\u0005E\u0442\nE\u0003E\u0005E\u0445\nE\u0003F',
+  '\u0003F\u0005F\u0449\nF\u0003F\u0003F\u0003F\u0003F\u0003F\u0003F\u0003',
+  'G\u0003G\u0005G\u0453\nG\u0003G\u0003G\u0003G\u0007G\u0458\nG\fG\u000e',
+  'G\u045b\u000bG\u0003H\u0003H\u0003H\u0003H\u0003H\u0003H\u0003H\u0003',
+  'H\u0003H\u0003H\u0005H\u0467\nH\u0003I\u0003I\u0005I\u046b\nI\u0003',
+  'I\u0003I\u0003J\u0003J\u0003J\u0003J\u0005J\u0473\nJ\u0003J\u0003J\u0003',
+  'K\u0003K\u0005K\u0479\nK\u0003K\u0003K\u0005K\u047d\nK\u0003K\u0003',
+  'K\u0005K\u0481\nK\u0003K\u0007K\u0484\nK\fK\u000eK\u0487\u000bK\u0003',
+  'L\u0003L\u0005L\u048b\nL\u0003L\u0003L\u0005L\u048f\nL\u0003L\u0003',
+  'L\u0003L\u0003L\u0005L\u0495\nL\u0003L\u0003L\u0005L\u0499\nL\u0003',
+  'L\u0003L\u0003L\u0003L\u0005L\u049f\nL\u0003L\u0003L\u0005L\u04a3\n',
+  'L\u0003L\u0003L\u0003L\u0003L\u0005L\u04a9\nL\u0003L\u0003L\u0005L\u04ad',
+  '\nL\u0003M\u0003M\u0005M\u04b1\nM\u0003M\u0003M\u0005M\u04b5\nM\u0003',
+  'M\u0003M\u0005M\u04b9\nM\u0003M\u0003M\u0005M\u04bd\nM\u0003M\u0007',
+  'M\u04c0\nM\fM\u000eM\u04c3\u000bM\u0003N\u0003N\u0003N\u0003N\u0005',
+  'N\u04c9\nN\u0003N\u0003N\u0005N\u04cd\nN\u0003N\u0007N\u04d0\nN\fN\u000e',
+  'N\u04d3\u000bN\u0003O\u0003O\u0003O\u0003O\u0005O\u04d9\nO\u0003P\u0003',
+  'P\u0005P\u04dd\nP\u0003P\u0003P\u0005P\u04e1\nP\u0003P\u0003P\u0003',
+  'P\u0003P\u0003P\u0003P\u0005P\u04e9\nP\u0003P\u0003P\u0003P\u0006P\u04ee',
+  '\nP\rP\u000eP\u04ef\u0003P\u0005P\u04f3\nP\u0003P\u0003P\u0003Q\u0003',
+  'Q\u0005Q\u04f9\nQ\u0003Q\u0005Q\u04fc\nQ\u0003Q\u0003Q\u0003Q\u0005',
+  'Q\u0501\nQ\u0003Q\u0005Q\u0504\nQ\u0003R\u0003R\u0005R\u0508\nR\u0003',
+  'R\u0005R\u050b\nR\u0003R\u0005R\u050e\nR\u0003R\u0003R\u0003S\u0003',
+  'S\u0003S\u0005S\u0515\nS\u0003S\u0003S\u0005S\u0519\nS\u0003S\u0003',
+  'S\u0005S\u051d\nS\u0003T\u0003T\u0005T\u0521\nT\u0003T\u0003T\u0005',
+  'T\u0525\nT\u0003T\u0007T\u0528\nT\fT\u000eT\u052b\u000bT\u0003T\u0003',
+  'T\u0005T\u052f\nT\u0003T\u0003T\u0005T\u0533\nT\u0003T\u0007T\u0536',
+  '\nT\fT\u000eT\u0539\u000bT\u0003T\u0003T\u0005T\u053d\nT\u0003T\u0005',
+  'T\u0540\nT\u0005T\u0542\nT\u0003U\u0003U\u0003U\u0003U\u0003U\u0003',
+  'U\u0003U\u0005U\u054b\nU\u0003V\u0003V\u0003V\u0003V\u0005V\u0551\n',
+  'V\u0003V\u0005V\u0554\nV\u0003W\u0003W\u0005W\u0558\nW\u0003W\u0005',
+  'W\u055b\nW\u0003X\u0003X\u0003X\u0003Y\u0003Y\u0005Y\u0562\nY\u0003',
+  'Y\u0005Y\u0565\nY\u0003Y\u0005Y\u0568\nY\u0003Y\u0003Y\u0005Y\u056c',
+  '\nY\u0003Y\u0007Y\u056f\nY\fY\u000eY\u0572\u000bY\u0003Y\u0005Y\u0575',
+  '\nY\u0003Y\u0003Y\u0003Z\u0003Z\u0003Z\u0003Z\u0005Z\u057d\nZ\u0003',
+  'Z\u0003Z\u0005Z\u0581\nZ\u0003Z\u0007Z\u0584\nZ\fZ\u000eZ\u0587\u000b',
+  'Z\u0003Z\u0003Z\u0005Z\u058b\nZ\u0003[\u0003[\u0005[\u058f\n[\u0003',
+  '\\\u0003\\\u0003\\\u0003\\\u0003\\\u0003\\\u0003]\u0003]\u0003^\u0003',
+  '^\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0005_\u05a1\n_\u0003_\u0003',
+  '_\u0005_\u05a5\n_\u0003_\u0007_\u05a8\n_\f_\u000e_\u05ab\u000b_\u0003',
+  '`\u0003`\u0003`\u0003`\u0003a\u0003a\u0003a\u0003a\u0003b\u0003b\u0005',
+  'b\u05b7\nb\u0003b\u0003b\u0005b\u05bb\nb\u0005b\u05bd\nb\u0003c\u0005',
+  'c\u05c0\nc\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0005c\u05c9',
+  '\nc\u0003c\u0003c\u0005c\u05cd\nc\u0003c\u0003c\u0005c\u05d1\nc\u0003',
+  'c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0005',
+  'c\u05dd\nc\u0003c\u0003c\u0005c\u05e1\nc\u0003c\u0007c\u05e4\nc\fc\u000e',
+  'c\u05e7\u000bc\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0005',
+  'c\u05f0\nc\u0003d\u0003d\u0003d\u0003d\u0005d\u05f6\nd\u0003d\u0003',
+  'd\u0005d\u05fa\nd\u0003d\u0007d\u05fd\nd\fd\u000ed\u0600\u000bd\u0003',
+  'd\u0005d\u0603\nd\u0003e\u0003e\u0005e\u0607\ne\u0003e\u0003e\u0005',
+  'e\u060b\ne\u0003e\u0003e\u0003f\u0003f\u0005f\u0611\nf\u0003g\u0003',
+  'g\u0005g\u0615\ng\u0003g\u0003g\u0003g\u0005g\u061a\ng\u0003h\u0003',
+  'h\u0003h\u0003h\u0005h\u0620\nh\u0003i\u0003i\u0003i\u0003i\u0003i\u0003',
+  'i\u0003i\u0005i\u0629\ni\u0003i\u0003i\u0003j\u0003j\u0003j\u0003j\u0003',
+  'j\u0005j\u0632\nj\u0003j\u0003j\u0003k\u0003k\u0003k\u0003k\u0005k\u063a',
+  '\nk\u0003k\u0003k\u0003l\u0003l\u0005l\u0640\nl\u0003l\u0003l\u0005',
+  'l\u0644\nl\u0003l\u0007l\u0647\nl\fl\u000el\u064a\u000bl\u0003m\u0003',
+  'm\u0003m\u0003m\u0003n\u0003n\u0005n\u0652\nn\u0003n\u0003n\u0005n\u0656',
+  '\nn\u0003n\u0007n\u0659\nn\fn\u000en\u065c\u000bn\u0003o\u0003o\u0005',
+  'o\u0660\no\u0003o\u0003o\u0005o\u0664\no\u0003o\u0003o\u0003o\u0005',
+  'o\u0669\no\u0003p\u0003p\u0005p\u066d\np\u0003q\u0003q\u0005q\u0671',
+  '\nq\u0003q\u0007q\u0674\nq\fq\u000eq\u0677\u000bq\u0003q\u0003q\u0003',
+  'q\u0003q\u0005q\u067d\nq\u0003r\u0003r\u0005r\u0681\nr\u0003r\u0003',
+  'r\u0005r\u0685\nr\u0005r\u0687\nr\u0003r\u0003r\u0005r\u068b\nr\u0005',
+  'r\u068d\nr\u0003r\u0003r\u0005r\u0691\nr\u0005r\u0693\nr\u0003r\u0003',
+  'r\u0003s\u0003s\u0005s\u0699\ns\u0003s\u0003s\u0003t\u0003t\u0005t\u069f',
+  '\nt\u0003t\u0005t\u06a2\nt\u0003t\u0005t\u06a5\nt\u0003t\u0003t\u0003',
+  'u\u0003u\u0005u\u06ab\nu\u0003u\u0003u\u0003u\u0005u\u06b0\nu\u0003',
+  'v\u0003v\u0005v\u06b4\nv\u0003v\u0003v\u0003v\u0005v\u06b9\nv\u0003',
+  'w\u0003w\u0005w\u06bd\nw\u0003w\u0003w\u0005w\u06c1\nw\u0005w\u06c3',
+  '\nw\u0003w\u0003w\u0005w\u06c7\nw\u0005w\u06c9\nw\u0003w\u0005w\u06cc',
+  '\nw\u0003w\u0003w\u0005w\u06d0\nw\u0005w\u06d2\nw\u0003w\u0003w\u0003',
+  'x\u0003x\u0005x\u06d8\nx\u0003y\u0003y\u0005y\u06dc\ny\u0003y\u0003',
+  'y\u0003z\u0003z\u0005z\u06e2\nz\u0003z\u0003z\u0007z\u06e6\nz\fz\u000e',
+  'z\u06e9\u000bz\u0003{\u0003{\u0003{\u0003|\u0005|\u06ef\n|\u0003|\u0003',
+  '|\u0003}\u0003}\u0005}\u06f5\n}\u0003}\u0007}\u06f8\n}\f}\u000e}\u06fb',
+  '\u000b}\u0003~\u0003~\u0003~\u0003\u007f\u0003\u007f\u0005\u007f\u0702',
+  '\n\u007f\u0003\u007f\u0003\u007f\u0005\u007f\u0706\n\u007f\u0005\u007f',
+  '\u0708\n\u007f\u0003\u007f\u0003\u007f\u0005\u007f\u070c\n\u007f\u0003',
+  '\u007f\u0003\u007f\u0005\u007f\u0710\n\u007f\u0005\u007f\u0712\n\u007f',
+  '\u0005\u007f\u0714\n\u007f\u0003\u0080\u0003\u0080\u0003\u0081\u0003',
+  '\u0081\u0003\u0082\u0003\u0082\u0003\u0083\u0003\u0083\u0003\u0083\u0003',
+  '\u0083\u0003\u0083\u0007\u0083\u0721\n\u0083\f\u0083\u000e\u0083\u0724',
+  '\u000b\u0083\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084',
+  '\u0007\u0084\u072b\n\u0084\f\u0084\u000e\u0084\u072e\u000b\u0084\u0003',
+  '\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0007\u0085\u0735',
+  '\n\u0085\f\u0085\u000e\u0085\u0738\u000b\u0085\u0003\u0086\u0003\u0086',
+  '\u0005\u0086\u073c\n\u0086\u0007\u0086\u073e\n\u0086\f\u0086\u000e\u0086',
+  '\u0741\u000b\u0086\u0003\u0086\u0003\u0086\u0003\u0087\u0003\u0087\u0005',
+  '\u0087\u0747\n\u0087\u0003\u0087\u0007\u0087\u074a\n\u0087\f\u0087\u000e',
+  '\u0087\u074d\u000b\u0087\u0003\u0088\u0003\u0088\u0005\u0088\u0751\n',
+  '\u0088\u0003\u0088\u0003\u0088\u0005\u0088\u0755\n\u0088\u0003\u0088',
+  '\u0003\u0088\u0005\u0088\u0759\n\u0088\u0003\u0088\u0003\u0088\u0005',
+  '\u0088\u075d\n\u0088\u0003\u0088\u0007\u0088\u0760\n\u0088\f\u0088\u000e',
+  '\u0088\u0763\u000b\u0088\u0003\u0089\u0003\u0089\u0005\u0089\u0767\n',
+  '\u0089\u0003\u0089\u0003\u0089\u0005\u0089\u076b\n\u0089\u0003\u0089',
+  '\u0003\u0089\u0005\u0089\u076f\n\u0089\u0003\u0089\u0003\u0089\u0005',
+  '\u0089\u0773\n\u0089\u0003\u0089\u0003\u0089\u0005\u0089\u0777\n\u0089',
+  '\u0003\u0089\u0003\u0089\u0005\u0089\u077b\n\u0089\u0003\u0089\u0007',
+  '\u0089\u077e\n\u0089\f\u0089\u000e\u0089\u0781\u000b\u0089\u0003\u008a',
+  '\u0003\u008a\u0005\u008a\u0785\n\u008a\u0003\u008a\u0003\u008a\u0005',
+  '\u008a\u0789\n\u008a\u0003\u008a\u0007\u008a\u078c\n\u008a\f\u008a\u000e',
+  '\u008a\u078f\u000b\u008a\u0003\u008b\u0003\u008b\u0005\u008b\u0793\n',
+  '\u008b\u0007\u008b\u0795\n\u008b\f\u008b\u000e\u008b\u0798\u000b\u008b',
+  '\u0003\u008b\u0003\u008b\u0003\u008c\u0003\u008c\u0005\u008c\u079e\n',
+  '\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0005',
+  '\u008c\u07a5\n\u008c\u0003\u008c\u0003\u008c\u0005\u008c\u07a9\n\u008c',
+  '\u0003\u008c\u0003\u008c\u0005\u008c\u07ad\n\u008c\u0003\u008c\u0003',
+  '\u008c\u0005\u008c\u07b1\n\u008c\u0003\u008c\u0003\u008c\u0003\u008c',
+  '\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c',
+  '\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0005\u008c\u07c0\n',
+  '\u008c\u0003\u008c\u0005\u008c\u07c3\n\u008c\u0003\u008c\u0003\u008c',
+  '\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c',
+  '\u0003\u008c\u0003\u008c\u0003\u008c\u0007\u008c\u07d0\n\u008c\f\u008c',
+  '\u000e\u008c\u07d3\u000b\u008c\u0003\u008d\u0003\u008d\u0005\u008d\u07d7',
+  '\n\u008d\u0003\u008d\u0003\u008d\u0005\u008d\u07db\n\u008d\u0007\u008d',
+  '\u07dd\n\u008d\f\u008d\u000e\u008d\u07e0\u000b\u008d\u0003\u008e\u0003',
+  '\u008e\u0005\u008e\u07e4\n\u008e\u0003\u008e\u0003\u008e\u0005\u008e',
+  '\u07e8\n\u008e\u0003\u008e\u0003\u008e\u0005\u008e\u07ec\n\u008e\u0003',
+  '\u008e\u0003\u008e\u0003\u008f\u0003\u008f\u0003\u0090\u0003\u0090\u0005',
+  '\u0090\u07f4\n\u0090\u0003\u0090\u0003\u0090\u0005\u0090\u07f8\n\u0090',
+  '\u0003\u0090\u0003\u0090\u0005\u0090\u07fc\n\u0090\u0003\u0090\u0003',
+  '\u0090\u0003\u0091\u0003\u0091\u0003\u0092\u0003\u0092\u0005\u0092\u0804',
+  '\n\u0092\u0003\u0092\u0003\u0092\u0005\u0092\u0808\n\u0092\u0003\u0092',
+  '\u0003\u0092\u0005\u0092\u080c\n\u0092\u0003\u0092\u0003\u0092\u0003',
+  '\u0093\u0003\u0093\u0003\u0094\u0003\u0094\u0005\u0094\u0814\n\u0094',
+  '\u0003\u0094\u0003\u0094\u0005\u0094\u0818\n\u0094\u0003\u0094\u0003',
+  '\u0094\u0005\u0094\u081c\n\u0094\u0003\u0094\u0003\u0094\u0003\u0095',
+  '\u0003\u0095\u0003\u0096\u0003\u0096\u0005\u0096\u0824\n\u0096\u0003',
+  '\u0096\u0003\u0096\u0005\u0096\u0828\n\u0096\u0003\u0096\u0003\u0096',
+  '\u0005\u0096\u082c\n\u0096\u0003\u0096\u0003\u0096\u0003\u0097\u0003',
+  '\u0097\u0003\u0098\u0003\u0098\u0005\u0098\u0834\n\u0098\u0003\u0098',
+  '\u0003\u0098\u0005\u0098\u0838\n\u0098\u0003\u0098\u0003\u0098\u0005',
+  '\u0098\u083c\n\u0098\u0003\u0098\u0003\u0098\u0003\u0099\u0003\u0099',
+  '\u0003\u009a\u0003\u009a\u0005\u009a\u0844\n\u009a\u0003\u009a\u0003',
+  '\u009a\u0005\u009a\u0848\n\u009a\u0003\u009a\u0003\u009a\u0005\u009a',
+  '\u084c\n\u009a\u0003\u009a\u0003\u009a\u0005\u009a\u0850\n\u009a\u0003',
+  '\u009a\u0005\u009a\u0853\n\u009a\u0003\u009a\u0005\u009a\u0856\n\u009a',
+  '\u0003\u009a\u0003\u009a\u0003\u009b\u0003\u009b\u0003\u009c\u0003\u009c',
+  '\u0005\u009c\u085e\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c\u0862',
+  '\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c\u0866\n\u009c\u0003\u009c',
+  '\u0003\u009c\u0005\u009c\u086a\n\u009c\u0003\u009c\u0003\u009c\u0005',
+  '\u009c\u086e\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c\u0872\n\u009c',
+  '\u0003\u009c\u0003\u009c\u0005\u009c\u0876\n\u009c\u0003\u009c\u0003',
+  '\u009c\u0005\u009c\u087a\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c',
+  '\u087e\n\u009c\u0003\u009c\u0003\u009c\u0003\u009d\u0003\u009d\u0003',
+  '\u009e\u0003\u009e\u0005\u009e\u0886\n\u009e\u0003\u009e\u0003\u009e',
+  '\u0005\u009e\u088a\n\u009e\u0003\u009e\u0003\u009e\u0005\u009e\u088e',
+  '\n\u009e\u0003\u009e\u0003\u009e\u0003\u009e\u0003\u009e\u0005\u009e',
+  '\u0894\n\u009e\u0003\u009e\u0003\u009e\u0005\u009e\u0898\n\u009e\u0003',
+  '\u009e\u0003\u009e\u0005\u009e\u089c\n\u009e\u0003\u009e\u0003\u009e',
+  '\u0005\u009e\u08a0\n\u009e\u0003\u009f\u0003\u009f\u0003\u00a0\u0003',
+  '\u00a0\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0005',
+  '\u00a1\u08ab\n\u00a1\u0003\u00a1\u0003\u00a1\u0005\u00a1\u08af\n\u00a1',
+  '\u0003\u00a1\u0003\u00a1\u0005\u00a1\u08b3\n\u00a1\u0003\u00a1\u0003',
+  '\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003',
+  '\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003',
+  '\u00a1\u0003\u00a1\u0003\u00a1\u0005\u00a1\u08c5\n\u00a1\u0003\u00a2',
+  '\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2',
+  '\u0005\u00a2\u08ce\n\u00a2\u0003\u00a3\u0003\u00a3\u0003\u00a4\u0003',
+  '\u00a4\u0003\u00a5\u0003\u00a5\u0005\u00a5\u08d6\n\u00a5\u0003\u00a5',
+  '\u0003\u00a5\u0005\u00a5\u08da\n\u00a5\u0003\u00a5\u0003\u00a5\u0005',
+  '\u00a5\u08de\n\u00a5\u0003\u00a5\u0003\u00a5\u0005\u00a5\u08e2\n\u00a5',
+  '\u0007\u00a5\u08e4\n\u00a5\f\u00a5\u000e\u00a5\u08e7\u000b\u00a5\u0005',
+  '\u00a5\u08e9\n\u00a5\u0003\u00a5\u0003\u00a5\u0003\u00a6\u0003\u00a6',
+  '\u0005\u00a6\u08ef\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005',
+  '\u00a6\u08f4\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6',
+  '\u08f9\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u08fe',
+  '\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u0903\n\u00a6',
+  '\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u0908\n\u00a6\u0003',
+  '\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u090d\n\u00a6\u0003\u00a6',
+  '\u0005\u00a6\u0910\n\u00a6\u0003\u00a7\u0003\u00a7\u0005\u00a7\u0914',
+  '\n\u00a7\u0003\u00a7\u0003\u00a7\u0005\u00a7\u0918\n\u00a7\u0003\u00a7',
+  '\u0003\u00a7\u0003\u00a8\u0003\u00a8\u0005\u00a8\u091e\n\u00a8\u0003',
+  '\u00a8\u0006\u00a8\u0921\n\u00a8\r\u00a8\u000e\u00a8\u0922\u0003\u00a9',
+  '\u0003\u00a9\u0005\u00a9\u0927\n\u00a9\u0003\u00a9\u0005\u00a9\u092a',
+  '\n\u00a9\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa',
+  '\u0003\u00aa\u0003\u00ab\u0003\u00ab\u0005\u00ab\u0934\n\u00ab\u0003',
+  '\u00ab\u0003\u00ab\u0005\u00ab\u0938\n\u00ab\u0003\u00ab\u0003\u00ab',
+  '\u0005\u00ab\u093c\n\u00ab\u0005\u00ab\u093e\n\u00ab\u0003\u00ab\u0003',
+  '\u00ab\u0005\u00ab\u0942\n\u00ab\u0003\u00ab\u0003\u00ab\u0005\u00ab',
+  '\u0946\n\u00ab\u0003\u00ab\u0003\u00ab\u0005\u00ab\u094a\n\u00ab\u0007',
+  '\u00ab\u094c\n\u00ab\f\u00ab\u000e\u00ab\u094f\u000b\u00ab\u0005\u00ab',
+  '\u0951\n\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ac\u0003\u00ac\u0003',
+  '\u00ac\u0003\u00ad\u0003\u00ad\u0003\u00ae\u0003\u00ae\u0003\u00af\u0003',
+  '\u00af\u0005\u00af\u095e\n\u00af\u0003\u00af\u0003\u00af\u0005\u00af',
+  '\u0962\n\u00af\u0003\u00af\u0003\u00af\u0005\u00af\u0966\n\u00af\u0003',
+  '\u00af\u0005\u00af\u0969\n\u00af\u0003\u00af\u0005\u00af\u096c\n\u00af',
+  '\u0003\u00af\u0003\u00af\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0972\n',
+  '\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0976\n\u00b0\u0003\u00b0',
+  '\u0003\u00b0\u0005\u00b0\u097a\n\u00b0\u0005\u00b0\u097c\n\u00b0\u0003',
+  '\u00b0\u0003\u00b0\u0005\u00b0\u0980\n\u00b0\u0003\u00b0\u0003\u00b0',
+  '\u0005\u00b0\u0984\n\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0988',
+  '\n\u00b0\u0005\u00b0\u098a\n\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0',
+  '\u098e\n\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0992\n\u00b0\u0003',
+  '\u00b0\u0003\u00b0\u0003\u00b1\u0003\u00b1\u0005\u00b1\u0998\n\u00b1',
+  '\u0003\u00b1\u0003\u00b1\u0003\u00b2\u0003\u00b2\u0005\u00b2\u099e\n',
+  '\u00b2\u0003\u00b2\u0006\u00b2\u09a1\n\u00b2\r\u00b2\u000e\u00b2\u09a2',
+  '\u0003\u00b2\u0003\u00b2\u0005\u00b2\u09a7\n\u00b2\u0003\u00b2\u0003',
+  '\u00b2\u0005\u00b2\u09ab\n\u00b2\u0003\u00b2\u0006\u00b2\u09ae\n\u00b2',
+  '\r\u00b2\u000e\u00b2\u09af\u0005\u00b2\u09b2\n\u00b2\u0003\u00b2\u0005',
+  '\u00b2\u09b5\n\u00b2\u0003\u00b2\u0003\u00b2\u0005\u00b2\u09b9\n\u00b2',
+  '\u0003\u00b2\u0005\u00b2\u09bc\n\u00b2\u0003\u00b2\u0005\u00b2\u09bf',
+  '\n\u00b2\u0003\u00b2\u0003\u00b2\u0003\u00b3\u0003\u00b3\u0005\u00b3',
+  '\u09c5\n\u00b3\u0003\u00b3\u0003\u00b3\u0005\u00b3\u09c9\n\u00b3\u0003',
+  '\u00b3\u0003\u00b3\u0005\u00b3\u09cd\n\u00b3\u0003\u00b3\u0003\u00b3',
+  '\u0003\u00b4\u0003\u00b4\u0003\u00b5\u0003\u00b5\u0005\u00b5\u09d5\n',
+  '\u00b5\u0003\u00b6\u0003\u00b6\u0005\u00b6\u09d9\n\u00b6\u0003\u00b6',
+  '\u0003\u00b6\u0005\u00b6\u09dd\n\u00b6\u0003\u00b6\u0003\u00b6\u0005',
+  '\u00b6\u09e1\n\u00b6\u0003\u00b6\u0003\u00b6\u0005\u00b6\u09e5\n\u00b6',
+  '\u0007\u00b6\u09e7\n\u00b6\f\u00b6\u000e\u00b6\u09ea\u000b\u00b6\u0005',
+  '\u00b6\u09ec\n\u00b6\u0003\u00b6\u0003\u00b6\u0003\u00b7\u0003\u00b7',
+  '\u0005\u00b7\u09f2\n\u00b7\u0003\u00b7\u0003\u00b7\u0005\u00b7\u09f6',
+  '\n\u00b7\u0003\u00b7\u0005\u00b7\u09f9\n\u00b7\u0003\u00b7\u0005\u00b7',
+  '\u09fc\n\u00b7\u0003\u00b7\u0003\u00b7\u0005\u00b7\u0a00\n\u00b7\u0003',
+  '\u00b7\u0007\u00b7\u0a03\n\u00b7\f\u00b7\u000e\u00b7\u0a06\u000b\u00b7',
+  '\u0003\u00b7\u0005\u00b7\u0a09\n\u00b7\u0003\u00b7\u0003\u00b7\u0003',
+  '\u00b8\u0003\u00b8\u0003\u00b8\u0003\u00b8\u0005\u00b8\u0a11\n\u00b8',
+  '\u0003\u00b9\u0003\u00b9\u0005\u00b9\u0a15\n\u00b9\u0003\u00b9\u0003',
+  '\u00b9\u0005\u00b9\u0a19\n\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00ba',
+  '\u0003\u00ba\u0003\u00ba\u0003\u00bb\u0003\u00bb\u0003\u00bc\u0003\u00bc',
+  '\u0003\u00bc\u0003\u00bd\u0003\u00bd\u0005\u00bd\u0a27\n\u00bd\u0003',
+  '\u00be\u0003\u00be\u0005\u00be\u0a2b\n\u00be\u0003\u00be\u0003\u00be',
+  '\u0005\u00be\u0a2f\n\u00be\u0003\u00be\u0003\u00be\u0003\u00bf\u0003',
+  '\u00bf\u0003\u00bf\u0003\u00c0\u0003\u00c0\u0005\u00c0\u0a38\n\u00c0',
+  '\u0003\u00c1\u0003\u00c1\u0005\u00c1\u0a3c\n\u00c1\u0003\u00c1\u0003',
+  '\u00c1\u0005\u00c1\u0a40\n\u00c1\u0003\u00c1\u0007\u00c1\u0a43\n\u00c1',
+  '\f\u00c1\u000e\u00c1\u0a46\u000b\u00c1\u0003\u00c2\u0003\u00c2\u0005',
+  '\u00c2\u0a4a\n\u00c2\u0003\u00c2\u0006\u00c2\u0a4d\n\u00c2\r\u00c2\u000e',
+  '\u00c2\u0a4e\u0003\u00c3\u0003\u00c3\u0005\u00c3\u0a53\n\u00c3\u0003',
+  '\u00c3\u0003\u00c3\u0005\u00c3\u0a57\n\u00c3\u0003\u00c3\u0007\u00c3',
+  '\u0a5a\n\u00c3\f\u00c3\u000e\u00c3\u0a5d\u000b\u00c3\u0003\u00c4\u0003',
+  '\u00c4\u0003\u00c5\u0003\u00c5\u0003\u00c6\u0003\u00c6\u0003\u00c7\u0003',
+  '\u00c7\u0003\u00c7\u0007\u00c7\u0a68\n\u00c7\f\u00c7\u000e\u00c7\u0a6b',
+  '\u000b\u00c7\u0003\u00c8\u0003\u00c8\u0003\u00c9\u0003\u00c9\u0003\u00ca',
+  '\u0003\u00ca\u0003\u00cb\u0003\u00cb\u0003\u00cb\u0003\u00cb\u0005\u00cb',
+  '\u0a77\n\u00cb\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u023b\u0002',
+  '\u00cd\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a',
+  '\u001c\u001e "$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080',
+  '\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098',
+  '\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0',
+  '\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8',
+  '\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0',
+  '\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8',
+  '\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110',
+  '\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128',
+  '\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140',
+  '\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158',
+  '\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170',
+  '\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188',
+  '\u018a\u018c\u018e\u0190\u0192\u0194\u0196\u0002\u000e\u0004\u0002\t',
+  '\t\u000f\u000f\u0003\u0002`c\u0003\u0002hi\u0004\u0002\u0005\u0005\u000f',
+  '\u000f\u0003\u0002{|\u0005\u0002uu\u0095\u0095\u0098\u0098\u0003\u0002',
+  '\u0089\u008b\u0003\u0002\u0093\u0094\u0004\u0002  %(\u0004\u0002!!)',
+  ',\u0004\u0002\u0005\u0005-7\u0003\u00028\u0085\u0002\u0ba5\u0002\u0198',
+  '\u0003\u0002\u0002\u0002\u0004\u01a6\u0003\u0002\u0002\u0002\u0006\u01af',
+  '\u0003\u0002\u0002\u0002\b\u01b4\u0003\u0002\u0002\u0002\n\u01bd\u0003',
+  '\u0002\u0002\u0002\f\u01cf\u0003\u0002\u0002\u0002\u000e\u01d1\u0003',
+  '\u0002\u0002\u0002\u0010\u01db\u0003\u0002\u0002\u0002\u0012\u01dd\u0003',
+  '\u0002\u0002\u0002\u0014\u01f1\u0003\u0002\u0002\u0002\u0016\u01f4\u0003',
+  '\u0002\u0002\u0002\u0018\u01fa\u0003\u0002\u0002\u0002\u001a\u0202\u0003',
+  '\u0002\u0002\u0002\u001c\u020a\u0003\u0002\u0002\u0002\u001e\u020c\u0003',
+  '\u0002\u0002\u0002 \u0214\u0003\u0002\u0002\u0002"\u0216\u0003\u0002',
+  '\u0002\u0002$\u021b\u0003\u0002\u0002\u0002&\u021d\u0003\u0002\u0002',
+  '\u0002(\u0220\u0003\u0002\u0002\u0002*\u0223\u0003\u0002\u0002\u0002',
+  ',\u022b\u0003\u0002\u0002\u0002.\u0234\u0003\u0002\u0002\u00020\u023f',
+  '\u0003\u0002\u0002\u00022\u0243\u0003\u0002\u0002\u00024\u0261\u0003',
+  '\u0002\u0002\u00026\u0263\u0003\u0002\u0002\u00028\u0289\u0003\u0002',
+  '\u0002\u0002:\u0291\u0003\u0002\u0002\u0002<\u0293\u0003\u0002\u0002',
+  '\u0002>\u02a1\u0003\u0002\u0002\u0002@\u02a8\u0003\u0002\u0002\u0002',
+  'B\u02b0\u0003\u0002\u0002\u0002D\u02b9\u0003\u0002\u0002\u0002F\u02bf',
+  '\u0003\u0002\u0002\u0002H\u02c1\u0003\u0002\u0002\u0002J\u02cd\u0003',
+  '\u0002\u0002\u0002L\u02cf\u0003\u0002\u0002\u0002N\u02d1\u0003\u0002',
+  '\u0002\u0002P\u02d3\u0003\u0002\u0002\u0002R\u02df\u0003\u0002\u0002',
+  '\u0002T\u02e3\u0003\u0002\u0002\u0002V\u02e5\u0003\u0002\u0002\u0002',
+  'X\u02ef\u0003\u0002\u0002\u0002Z\u02f5\u0003\u0002\u0002\u0002\\\u02ff',
+  '\u0003\u0002\u0002\u0002^\u0308\u0003\u0002\u0002\u0002`\u031e\u0003',
+  '\u0002\u0002\u0002b\u032e\u0003\u0002\u0002\u0002d\u033a\u0003\u0002',
+  '\u0002\u0002f\u033c\u0003\u0002\u0002\u0002h\u0340\u0003\u0002\u0002',
+  '\u0002j\u0344\u0003\u0002\u0002\u0002l\u0348\u0003\u0002\u0002\u0002',
+  'n\u034c\u0003\u0002\u0002\u0002p\u0350\u0003\u0002\u0002\u0002r\u0354',
+  '\u0003\u0002\u0002\u0002t\u0358\u0003\u0002\u0002\u0002v\u035c\u0003',
+  '\u0002\u0002\u0002x\u0360\u0003\u0002\u0002\u0002z\u0364\u0003\u0002',
+  '\u0002\u0002|\u0378\u0003\u0002\u0002\u0002~\u0393\u0003\u0002\u0002',
+  '\u0002\u0080\u03b8\u0003\u0002\u0002\u0002\u0082\u03cf\u0003\u0002\u0002',
+  '\u0002\u0084\u0418\u0003\u0002\u0002\u0002\u0086\u041a\u0003\u0002\u0002',
+  '\u0002\u0088\u0433\u0003\u0002\u0002\u0002\u008a\u0446\u0003\u0002\u0002',
+  '\u0002\u008c\u0450\u0003\u0002\u0002\u0002\u008e\u0466\u0003\u0002\u0002',
+  '\u0002\u0090\u0468\u0003\u0002\u0002\u0002\u0092\u046e\u0003\u0002\u0002',
+  '\u0002\u0094\u0476\u0003\u0002\u0002\u0002\u0096\u04ac\u0003\u0002\u0002',
+  '\u0002\u0098\u04b0\u0003\u0002\u0002\u0002\u009a\u04c4\u0003\u0002\u0002',
+  '\u0002\u009c\u04d8\u0003\u0002\u0002\u0002\u009e\u04da\u0003\u0002\u0002',
+  '\u0002\u00a0\u04f6\u0003\u0002\u0002\u0002\u00a2\u0505\u0003\u0002\u0002',
+  '\u0002\u00a4\u0511\u0003\u0002\u0002\u0002\u00a6\u0541\u0003\u0002\u0002',
+  '\u0002\u00a8\u054a\u0003\u0002\u0002\u0002\u00aa\u054c\u0003\u0002\u0002',
+  '\u0002\u00ac\u0555\u0003\u0002\u0002\u0002\u00ae\u055c\u0003\u0002\u0002',
+  '\u0002\u00b0\u055f\u0003\u0002\u0002\u0002\u00b2\u0578\u0003\u0002\u0002',
+  '\u0002\u00b4\u058e\u0003\u0002\u0002\u0002\u00b6\u0590\u0003\u0002\u0002',
+  '\u0002\u00b8\u0596\u0003\u0002\u0002\u0002\u00ba\u0598\u0003\u0002\u0002',
+  '\u0002\u00bc\u059a\u0003\u0002\u0002\u0002\u00be\u05ac\u0003\u0002\u0002',
+  '\u0002\u00c0\u05b0\u0003\u0002\u0002\u0002\u00c2\u05b4\u0003\u0002\u0002',
+  '\u0002\u00c4\u05bf\u0003\u0002\u0002\u0002\u00c6\u05f1\u0003\u0002\u0002',
+  '\u0002\u00c8\u0604\u0003\u0002\u0002\u0002\u00ca\u0610\u0003\u0002\u0002',
+  '\u0002\u00cc\u0612\u0003\u0002\u0002\u0002\u00ce\u061b\u0003\u0002\u0002',
+  '\u0002\u00d0\u0621\u0003\u0002\u0002\u0002\u00d2\u062c\u0003\u0002\u0002',
+  '\u0002\u00d4\u0635\u0003\u0002\u0002\u0002\u00d6\u063d\u0003\u0002\u0002',
+  '\u0002\u00d8\u064b\u0003\u0002\u0002\u0002\u00da\u064f\u0003\u0002\u0002',
+  '\u0002\u00dc\u0668\u0003\u0002\u0002\u0002\u00de\u066c\u0003\u0002\u0002',
+  '\u0002\u00e0\u067c\u0003\u0002\u0002\u0002\u00e2\u067e\u0003\u0002\u0002',
+  '\u0002\u00e4\u0696\u0003\u0002\u0002\u0002\u00e6\u069c\u0003\u0002\u0002',
+  '\u0002\u00e8\u06af\u0003\u0002\u0002\u0002\u00ea\u06b8\u0003\u0002\u0002',
+  '\u0002\u00ec\u06ba\u0003\u0002\u0002\u0002\u00ee\u06d7\u0003\u0002\u0002',
+  '\u0002\u00f0\u06d9\u0003\u0002\u0002\u0002\u00f2\u06df\u0003\u0002\u0002',
+  '\u0002\u00f4\u06ea\u0003\u0002\u0002\u0002\u00f6\u06ee\u0003\u0002\u0002',
+  '\u0002\u00f8\u06f2\u0003\u0002\u0002\u0002\u00fa\u06fc\u0003\u0002\u0002',
+  '\u0002\u00fc\u06ff\u0003\u0002\u0002\u0002\u00fe\u0715\u0003\u0002\u0002',
+  '\u0002\u0100\u0717\u0003\u0002\u0002\u0002\u0102\u0719\u0003\u0002\u0002',
+  '\u0002\u0104\u071b\u0003\u0002\u0002\u0002\u0106\u0725\u0003\u0002\u0002',
+  '\u0002\u0108\u072f\u0003\u0002\u0002\u0002\u010a\u073f\u0003\u0002\u0002',
+  '\u0002\u010c\u0744\u0003\u0002\u0002\u0002\u010e\u074e\u0003\u0002\u0002',
+  '\u0002\u0110\u0764\u0003\u0002\u0002\u0002\u0112\u0782\u0003\u0002\u0002',
+  '\u0002\u0114\u0796\u0003\u0002\u0002\u0002\u0116\u079b\u0003\u0002\u0002',
+  '\u0002\u0118\u07d4\u0003\u0002\u0002\u0002\u011a\u07e1\u0003\u0002\u0002',
+  '\u0002\u011c\u07ef\u0003\u0002\u0002\u0002\u011e\u07f1\u0003\u0002\u0002',
+  '\u0002\u0120\u07ff\u0003\u0002\u0002\u0002\u0122\u0801\u0003\u0002\u0002',
+  '\u0002\u0124\u080f\u0003\u0002\u0002\u0002\u0126\u0811\u0003\u0002\u0002',
+  '\u0002\u0128\u081f\u0003\u0002\u0002\u0002\u012a\u0821\u0003\u0002\u0002',
+  '\u0002\u012c\u082f\u0003\u0002\u0002\u0002\u012e\u0831\u0003\u0002\u0002',
+  '\u0002\u0130\u083f\u0003\u0002\u0002\u0002\u0132\u0841\u0003\u0002\u0002',
+  '\u0002\u0134\u0859\u0003\u0002\u0002\u0002\u0136\u085b\u0003\u0002\u0002',
+  '\u0002\u0138\u0881\u0003\u0002\u0002\u0002\u013a\u089f\u0003\u0002\u0002',
+  '\u0002\u013c\u08a1\u0003\u0002\u0002\u0002\u013e\u08a3\u0003\u0002\u0002',
+  '\u0002\u0140\u08c4\u0003\u0002\u0002\u0002\u0142\u08cd\u0003\u0002\u0002',
+  '\u0002\u0144\u08cf\u0003\u0002\u0002\u0002\u0146\u08d1\u0003\u0002\u0002',
+  '\u0002\u0148\u08d3\u0003\u0002\u0002\u0002\u014a\u090f\u0003\u0002\u0002',
+  '\u0002\u014c\u0911\u0003\u0002\u0002\u0002\u014e\u091b\u0003\u0002\u0002',
+  '\u0002\u0150\u0924\u0003\u0002\u0002\u0002\u0152\u092b\u0003\u0002\u0002',
+  '\u0002\u0154\u0931\u0003\u0002\u0002\u0002\u0156\u0954\u0003\u0002\u0002',
+  '\u0002\u0158\u0957\u0003\u0002\u0002\u0002\u015a\u0959\u0003\u0002\u0002',
+  '\u0002\u015c\u095b\u0003\u0002\u0002\u0002\u015e\u096f\u0003\u0002\u0002',
+  '\u0002\u0160\u0995\u0003\u0002\u0002\u0002\u0162\u09b1\u0003\u0002\u0002',
+  '\u0002\u0164\u09c2\u0003\u0002\u0002\u0002\u0166\u09d0\u0003\u0002\u0002',
+  '\u0002\u0168\u09d4\u0003\u0002\u0002\u0002\u016a\u09d6\u0003\u0002\u0002',
+  '\u0002\u016c\u09ef\u0003\u0002\u0002\u0002\u016e\u0a10\u0003\u0002\u0002',
+  '\u0002\u0170\u0a12\u0003\u0002\u0002\u0002\u0172\u0a1c\u0003\u0002\u0002',
+  '\u0002\u0174\u0a1f\u0003\u0002\u0002\u0002\u0176\u0a21\u0003\u0002\u0002',
+  '\u0002\u0178\u0a26\u0003\u0002\u0002\u0002\u017a\u0a28\u0003\u0002\u0002',
+  '\u0002\u017c\u0a32\u0003\u0002\u0002\u0002\u017e\u0a37\u0003\u0002\u0002',
+  '\u0002\u0180\u0a39\u0003\u0002\u0002\u0002\u0182\u0a47\u0003\u0002\u0002',
+  '\u0002\u0184\u0a50\u0003\u0002\u0002\u0002\u0186\u0a5e\u0003\u0002\u0002',
+  '\u0002\u0188\u0a60\u0003\u0002\u0002\u0002\u018a\u0a62\u0003\u0002\u0002',
+  '\u0002\u018c\u0a69\u0003\u0002\u0002\u0002\u018e\u0a6c\u0003\u0002\u0002',
+  '\u0002\u0190\u0a6e\u0003\u0002\u0002\u0002\u0192\u0a70\u0003\u0002\u0002',
+  '\u0002\u0194\u0a76\u0003\u0002\u0002\u0002\u0196\u0a78\u0003\u0002\u0002',
+  '\u0002\u0198\u019d\u0005\u0004\u0003\u0002\u0199\u019a\u0007\u0003\u0002',
+  '\u0002\u019a\u019c\u0005\u0004\u0003\u0002\u019b\u0199\u0003\u0002\u0002',
+  '\u0002\u019c\u019f\u0003\u0002\u0002\u0002\u019d\u019b\u0003\u0002\u0002',
+  '\u0002\u019d\u019e\u0003\u0002\u0002\u0002\u019e\u01a1\u0003\u0002\u0002',
+  '\u0002\u019f\u019d\u0003\u0002\u0002\u0002\u01a0\u01a2\u0007\u0003\u0002',
+  '\u0002\u01a1\u01a0\u0003\u0002\u0002\u0002\u01a1\u01a2\u0003\u0002\u0002',
+  '\u0002\u01a2\u01a3\u0003\u0002\u0002\u0002\u01a3\u01a4\u0007\u0002\u0002',
+  '\u0003\u01a4\u0003\u0003\u0002\u0002\u0002\u01a5\u01a7\u0007\u0099\u0002',
+  '\u0002\u01a6\u01a5\u0003\u0002\u0002\u0002\u01a6\u01a7\u0003\u0002\u0002',
+  '\u0002\u01a7\u01aa\u0003\u0002\u0002\u0002\u01a8\u01ab\u0005B"\u0002',
+  '\u01a9\u01ab\u0005\u0006\u0004\u0002\u01aa\u01a8\u0003\u0002\u0002\u0002',
+  '\u01aa\u01a9\u0003\u0002\u0002\u0002\u01ab\u01ad\u0003\u0002\u0002\u0002',
+  '\u01ac\u01ae\u0007\u0099\u0002\u0002\u01ad\u01ac\u0003\u0002\u0002\u0002',
+  '\u01ad\u01ae\u0003\u0002\u0002\u0002\u01ae\u0005\u0003\u0002\u0002\u0002',
+  '\u01af\u01b2\u0005\b\u0005\u0002\u01b0\u01b1\u0007\u0099\u0002\u0002',
+  '\u01b1\u01b3\u0005\n\u0006\u0002\u01b2\u01b0\u0003\u0002\u0002\u0002',
+  '\u01b2\u01b3\u0003\u0002\u0002\u0002\u01b3\u0007\u0003\u0002\u0002\u0002',
+  '\u01b4\u01b5\u0007\u0004\u0002\u0002\u01b5\u01ba\u0005\u0194\u00cb\u0002',
+  '\u01b6\u01b7\u0007\u0005\u0002\u0002\u01b7\u01b9\u0005\u0194\u00cb\u0002',
+  '\u01b8\u01b6\u0003\u0002\u0002\u0002\u01b9\u01bc\u0003\u0002\u0002\u0002',
+  '\u01ba\u01b8\u0003\u0002\u0002\u0002\u01ba\u01bb\u0003\u0002\u0002\u0002',
+  '\u01bb\t\u0003\u0002\u0002\u0002\u01bc\u01ba\u0003\u0002\u0002\u0002',
+  '\u01bd\u01c2\u0005\f\u0007\u0002\u01be\u01bf\u0007\u0099\u0002\u0002',
+  '\u01bf\u01c1\u0005\f\u0007\u0002\u01c0\u01be\u0003\u0002\u0002\u0002',
+  '\u01c1\u01c4\u0003\u0002\u0002\u0002\u01c2\u01c0\u0003\u0002\u0002\u0002',
+  '\u01c2\u01c3\u0003\u0002\u0002\u0002\u01c3\u000b\u0003\u0002\u0002\u0002',
+  '\u01c4\u01c2\u0003\u0002\u0002\u0002\u01c5\u01d0\u0005\u0010\t\u0002',
+  '\u01c6\u01d0\u00052\u001a\u0002\u01c7\u01d0\u0005\u000e\b\u0002\u01c8',
+  '\u01d0\u0005\u016a\u00b6\u0002\u01c9\u01d0\u0005<\u001f\u0002\u01ca',
+  '\u01d0\u0005\u0144\u00a3\u0002\u01cb\u01d0\u0005\u0168\u00b5\u0002\u01cc',
+  '\u01d0\u0005\u0146\u00a4\u0002\u01cd\u01d0\u0005@!\u0002\u01ce\u01d0',
+  '\u0005> \u0002\u01cf\u01c5\u0003\u0002\u0002\u0002\u01cf\u01c6\u0003',
+  '\u0002\u0002\u0002\u01cf\u01c7\u0003\u0002\u0002\u0002\u01cf\u01c8\u0003',
+  '\u0002\u0002\u0002\u01cf\u01c9\u0003\u0002\u0002\u0002\u01cf\u01ca\u0003',
+  '\u0002\u0002\u0002\u01cf\u01cb\u0003\u0002\u0002\u0002\u01cf\u01cc\u0003',
+  '\u0002\u0002\u0002\u01cf\u01cd\u0003\u0002\u0002\u0002\u01cf\u01ce\u0003',
+  '\u0002\u0002\u0002\u01d0\r\u0003\u0002\u0002\u0002\u01d1\u01d3\u0005',
+  '\u0194\u00cb\u0002\u01d2\u01d4\u0007\u0099\u0002\u0002\u01d3\u01d2\u0003',
+  '\u0002\u0002\u0002\u01d3\u01d4\u0003\u0002\u0002\u0002\u01d4\u01d5\u0003',
+  '\u0002\u0002\u0002\u01d5\u01d7\u0007\u0006\u0002\u0002\u01d6\u01d8\u0007',
+  '\u0099\u0002\u0002\u01d7\u01d6\u0003\u0002\u0002\u0002\u01d7\u01d8\u0003',
+  '\u0002\u0002\u0002\u01d8\u01d9\u0003\u0002\u0002\u0002\u01d9\u01da\u0005',
+  '\u0102\u0082\u0002\u01da\u000f\u0003\u0002\u0002\u0002\u01db\u01dc\u0005',
+  '\u0012\n\u0002\u01dc\u0011\u0003\u0002\u0002\u0002\u01dd\u01de\u0005',
+  '\u0014\u000b\u0002\u01de\u01e0\u0007\u0007\u0002\u0002\u01df\u01e1\u0005',
+  '"\u0012\u0002\u01e0\u01df\u0003\u0002\u0002\u0002\u01e0\u01e1\u0003',
+  '\u0002\u0002\u0002\u01e1\u01e2\u0003\u0002\u0002\u0002\u01e2\u01e5\u0005',
+  '\u0016\f\u0002\u01e3\u01e4\u0007\u0004\u0002\u0002\u01e4\u01e6\u0005',
+  '\u001c\u000f\u0002\u01e5\u01e3\u0003\u0002\u0002\u0002\u01e5\u01e6\u0003',
+  '\u0002\u0002\u0002\u01e6\u01e9\u0003\u0002\u0002\u0002\u01e7\u01e8\u0007',
+  '\b\u0002\u0002\u01e8\u01ea\u0005\u001e\u0010\u0002\u01e9\u01e7\u0003',
+  '\u0002\u0002\u0002\u01e9\u01ea\u0003\u0002\u0002\u0002\u01ea\u01ec\u0003',
+  '\u0002\u0002\u0002\u01eb\u01ed\u0005(\u0015\u0002\u01ec\u01eb\u0003',
+  '\u0002\u0002\u0002\u01ec\u01ed\u0003\u0002\u0002\u0002\u01ed\u01ef\u0003',
+  '\u0002\u0002\u0002\u01ee\u01f0\u0005&\u0014\u0002\u01ef\u01ee\u0003',
+  '\u0002\u0002\u0002\u01ef\u01f0\u0003\u0002\u0002\u0002\u01f0\u0013\u0003',
+  '\u0002\u0002\u0002\u01f1\u01f2\u0005.\u0018\u0002\u01f2\u0015\u0003',
+  '\u0002\u0002\u0002\u01f3\u01f5\u0007\b\u0002\u0002\u01f4\u01f3\u0003',
+  '\u0002\u0002\u0002\u01f4\u01f5\u0003\u0002\u0002\u0002\u01f5\u01f8\u0003',
+  '\u0002\u0002\u0002\u01f6\u01f9\u0005\u0018\r\u0002\u01f7\u01f9\u0005',
+  '\u001a\u000e\u0002\u01f8\u01f6\u0003\u0002\u0002\u0002\u01f8\u01f7\u0003',
+  '\u0002\u0002\u0002\u01f9\u0017\u0003\u0002\u0002\u0002\u01fa\u01ff\u0005',
+  '.\u0018\u0002\u01fb\u01fc\u0007\t\u0002\u0002\u01fc\u01fe\u0005.\u0018',
+  '\u0002\u01fd\u01fb\u0003\u0002\u0002\u0002\u01fe\u0201\u0003\u0002\u0002',
+  '\u0002\u01ff\u01fd\u0003\u0002\u0002\u0002\u01ff\u0200\u0003\u0002\u0002',
+  '\u0002\u0200\u0019\u0003\u0002\u0002\u0002\u0201\u01ff\u0003\u0002\u0002',
+  '\u0002\u0202\u0203\u00050\u0019\u0002\u0203\u0204\u0007\t\u0002\u0002',
+  '\u0204\u0205\u00050\u0019\u0002\u0205\u0206\u0007\t\u0002\u0002\u0206',
+  '\u0207\u00050\u0019\u0002\u0207\u0208\u0007\t\u0002\u0002\u0208\u0209',
+  '\u00050\u0019\u0002\u0209\u001b\u0003\u0002\u0002\u0002\u020a\u020b',
+  '\u00050\u0019\u0002\u020b\u001d\u0003\u0002\u0002\u0002\u020c\u0211',
+  '\u0005.\u0018\u0002\u020d\u020e\u0007\b\u0002\u0002\u020e\u0210\u0005',
+  '.\u0018\u0002\u020f\u020d\u0003\u0002\u0002\u0002\u0210\u0213\u0003',
+  '\u0002\u0002\u0002\u0211\u020f\u0003\u0002\u0002\u0002\u0211\u0212\u0003',
+  '\u0002\u0002\u0002\u0212\u001f\u0003\u0002\u0002\u0002\u0213\u0211\u0003',
+  '\u0002\u0002\u0002\u0214\u0215\u0005.\u0018\u0002\u0215!\u0003\u0002',
+  '\u0002\u0002\u0216\u0217\u0005 \u0011\u0002\u0217\u0218\u0007\u0004',
+  '\u0002\u0002\u0218\u0219\u0005$\u0013\u0002\u0219\u021a\u0007\n\u0002',
+  '\u0002\u021a#\u0003\u0002\u0002\u0002\u021b\u021c\u0005.\u0018\u0002',
+  '\u021c%\u0003\u0002\u0002\u0002\u021d\u021e\u0007\u000b\u0002\u0002',
+  "\u021e\u021f\u0005.\u0018\u0002\u021f'\u0003\u0002\u0002\u0002\u0220",
+  '\u0221\u0007\f\u0002\u0002\u0221\u0222\u0005*\u0016\u0002\u0222)\u0003',
+  '\u0002\u0002\u0002\u0223\u0228\u0005,\u0017\u0002\u0224\u0225\u0007',
+  '\r\u0002\u0002\u0225\u0227\u0005,\u0017\u0002\u0226\u0224\u0003\u0002',
+  '\u0002\u0002\u0227\u022a\u0003\u0002\u0002\u0002\u0228\u0226\u0003\u0002',
+  '\u0002\u0002\u0228\u0229\u0003\u0002\u0002\u0002\u0229+\u0003\u0002',
+  '\u0002\u0002\u022a\u0228\u0003\u0002\u0002\u0002\u022b\u0232\u0005.',
+  '\u0018\u0002\u022c\u0230\u0007\u000e\u0002\u0002\u022d\u0231\u0005.',
+  '\u0018\u0002\u022e\u0231\u00050\u0019\u0002\u022f\u0231\u0007\u0087',
+  '\u0002\u0002\u0230\u022d\u0003\u0002\u0002\u0002\u0230\u022e\u0003\u0002',
+  '\u0002\u0002\u0230\u022f\u0003\u0002\u0002\u0002\u0231\u0233\u0003\u0002',
+  '\u0002\u0002\u0232\u022c\u0003\u0002\u0002\u0002\u0232\u0233\u0003\u0002',
+  '\u0002\u0002\u0233-\u0003\u0002\u0002\u0002\u0234\u023b\u0005\u0194',
+  '\u00cb\u0002\u0235\u0237\t\u0002\u0002\u0002\u0236\u0235\u0003\u0002',
+  '\u0002\u0002\u0236\u0237\u0003\u0002\u0002\u0002\u0237\u0238\u0003\u0002',
+  '\u0002\u0002\u0238\u023a\u0005\u0194\u00cb\u0002\u0239\u0236\u0003\u0002',
+  '\u0002\u0002\u023a\u023d\u0003\u0002\u0002\u0002\u023b\u023c\u0003\u0002',
+  '\u0002\u0002\u023b\u0239\u0003\u0002\u0002\u0002\u023c/\u0003\u0002',
+  '\u0002\u0002\u023d\u023b\u0003\u0002\u0002\u0002\u023e\u0240\u0005\u0188',
+  '\u00c5\u0002\u023f\u023e\u0003\u0002\u0002\u0002\u0240\u0241\u0003\u0002',
+  '\u0002\u0002\u0241\u023f\u0003\u0002\u0002\u0002\u0241\u0242\u0003\u0002',
+  '\u0002\u0002\u02421\u0003\u0002\u0002\u0002\u0243\u0244\u0005:\u001e',
+  '\u0002\u02443\u0003\u0002\u0002\u0002\u0245\u0247\u0007\u0010\u0002',
+  '\u0002\u0246\u0248\u0007\u0099\u0002\u0002\u0247\u0246\u0003\u0002\u0002',
+  '\u0002\u0247\u0248\u0003\u0002\u0002\u0002\u0248\u0249\u0003\u0002\u0002',
+  '\u0002\u0249\u024b\u00056\u001c\u0002\u024a\u024c\u0007\u0099\u0002',
+  '\u0002\u024b\u024a\u0003\u0002\u0002\u0002\u024b\u024c\u0003\u0002\u0002',
+  '\u0002\u024c\u0257\u0003\u0002\u0002\u0002\u024d\u024f\u0007\u0011\u0002',
+  '\u0002\u024e\u0250\u0007\u0099\u0002\u0002\u024f\u024e\u0003\u0002\u0002',
+  '\u0002\u024f\u0250\u0003\u0002\u0002\u0002\u0250\u0251\u0003\u0002\u0002',
+  '\u0002\u0251\u0253\u00056\u001c\u0002\u0252\u0254\u0007\u0099\u0002',
+  '\u0002\u0253\u0252\u0003\u0002\u0002\u0002\u0253\u0254\u0003\u0002\u0002',
+  '\u0002\u0254\u0256\u0003\u0002\u0002\u0002\u0255\u024d\u0003\u0002\u0002',
+  '\u0002\u0256\u0259\u0003\u0002\u0002\u0002\u0257\u0255\u0003\u0002\u0002',
+  '\u0002\u0257\u0258\u0003\u0002\u0002\u0002\u0258\u025a\u0003\u0002\u0002',
+  '\u0002\u0259\u0257\u0003\u0002\u0002\u0002\u025a\u025b\u0007\u0012\u0002',
+  '\u0002\u025b\u0262\u0003\u0002\u0002\u0002\u025c\u025e\u0007\u0010\u0002',
+  '\u0002\u025d\u025f\u0007\u0099\u0002\u0002\u025e\u025d\u0003\u0002\u0002',
+  '\u0002\u025e\u025f\u0003\u0002\u0002\u0002\u025f\u0260\u0003\u0002\u0002',
+  '\u0002\u0260\u0262\u0007\u0012\u0002\u0002\u0261\u0245\u0003\u0002\u0002',
+  '\u0002\u0261\u025c\u0003\u0002\u0002\u0002\u02625\u0003\u0002\u0002',
+  '\u0002\u0263\u0265\u0005\u0144\u00a3\u0002\u0264\u0266\u0007\u0099\u0002',
+  '\u0002\u0265\u0264\u0003\u0002\u0002\u0002\u0265\u0266\u0003\u0002\u0002',
+  '\u0002\u0266\u0267\u0003\u0002\u0002\u0002\u0267\u0269\u0007\u0004\u0002',
+  '\u0002\u0268\u026a\u0007\u0099\u0002\u0002\u0269\u0268\u0003\u0002\u0002',
+  '\u0002\u0269\u026a\u0003\u0002\u0002\u0002\u026a\u026b\u0003\u0002\u0002',
+  '\u0002\u026b\u026c\u0005:\u001e\u0002\u026c7\u0003\u0002\u0002\u0002',
+  '\u026d\u026f\u0007\u0013\u0002\u0002\u026e\u0270\u0007\u0099\u0002\u0002',
+  '\u026f\u026e\u0003\u0002\u0002\u0002\u026f\u0270\u0003\u0002\u0002\u0002',
+  '\u0270\u0271\u0003\u0002\u0002\u0002\u0271\u0273\u0005:\u001e\u0002',
+  '\u0272\u0274\u0007\u0099\u0002\u0002\u0273\u0272\u0003\u0002\u0002\u0002',
+  '\u0273\u0274\u0003\u0002\u0002\u0002\u0274\u027f\u0003\u0002\u0002\u0002',
+  '\u0275\u0277\u0007\u0011\u0002\u0002\u0276\u0278\u0007\u0099\u0002\u0002',
+  '\u0277\u0276\u0003\u0002\u0002\u0002\u0277\u0278\u0003\u0002\u0002\u0002',
+  '\u0278\u0279\u0003\u0002\u0002\u0002\u0279\u027b\u0005:\u001e\u0002',
+  '\u027a\u027c\u0007\u0099\u0002\u0002\u027b\u027a\u0003\u0002\u0002\u0002',
+  '\u027b\u027c\u0003\u0002\u0002\u0002\u027c\u027e\u0003\u0002\u0002\u0002',
+  '\u027d\u0275\u0003\u0002\u0002\u0002\u027e\u0281\u0003\u0002\u0002\u0002',
+  '\u027f\u027d\u0003\u0002\u0002\u0002\u027f\u0280\u0003\u0002\u0002\u0002',
+  '\u0280\u0282\u0003\u0002\u0002\u0002\u0281\u027f\u0003\u0002\u0002\u0002',
+  '\u0282\u0283\u0007\u0014\u0002\u0002\u0283\u028a\u0003\u0002\u0002\u0002',
+  '\u0284\u0286\u0007\u0013\u0002\u0002\u0285\u0287\u0007\u0099\u0002\u0002',
+  '\u0286\u0285\u0003\u0002\u0002\u0002\u0286\u0287\u0003\u0002\u0002\u0002',
+  '\u0287\u0288\u0003\u0002\u0002\u0002\u0288\u028a\u0007\u0014\u0002\u0002',
+  '\u0289\u026d\u0003\u0002\u0002\u0002\u0289\u0284\u0003\u0002\u0002\u0002',
+  '\u028a9\u0003\u0002\u0002\u0002\u028b\u0292\u0005\u0144\u00a3\u0002',
+  '\u028c\u0292\u0005\u0168\u00b5\u0002\u028d\u0292\u00054\u001b\u0002',
+  '\u028e\u0292\u00058\u001d\u0002\u028f\u0292\u0005\u0146\u00a4\u0002',
+  '\u0290\u0292\u0007t\u0002\u0002\u0291\u028b\u0003\u0002\u0002\u0002',
+  '\u0291\u028c\u0003\u0002\u0002\u0002\u0291\u028d\u0003\u0002\u0002\u0002',
+  '\u0291\u028e\u0003\u0002\u0002\u0002\u0291\u028f\u0003\u0002\u0002\u0002',
+  '\u0291\u0290\u0003\u0002\u0002\u0002\u0292;\u0003\u0002\u0002\u0002',
+  '\u0293\u0294\u0005\u0166\u00b4\u0002\u0294\u0295\u0007\u0004\u0002\u0002',
+  '\u0295\u029a\u0007\u0099\u0002\u0002\u0296\u029b\u0007\u0086\u0002\u0002',
+  '\u0297\u029b\u0005\u0168\u00b5\u0002\u0298\u029b\u0005\u0146\u00a4\u0002',
+  '\u0299\u029b\u0005\u0194\u00cb\u0002\u029a\u0296\u0003\u0002\u0002\u0002',
+  '\u029a\u0297\u0003\u0002\u0002\u0002\u029a\u0298\u0003\u0002\u0002\u0002',
+  '\u029a\u0299\u0003\u0002\u0002\u0002\u029b=\u0003\u0002\u0002\u0002',
+  '\u029c\u029f\u0007\b\u0002\u0002\u029d\u02a0\u0005\u0194\u00cb\u0002',
+  '\u029e\u02a0\u0005\u0168\u00b5\u0002\u029f\u029d\u0003\u0002\u0002\u0002',
+  '\u029f\u029e\u0003\u0002\u0002\u0002\u02a0\u02a2\u0003\u0002\u0002\u0002',
+  '\u02a1\u029c\u0003\u0002\u0002\u0002\u02a2\u02a3\u0003\u0002\u0002\u0002',
+  '\u02a3\u02a1\u0003\u0002\u0002\u0002\u02a3\u02a4\u0003\u0002\u0002\u0002',
+  '\u02a4\u02a6\u0003\u0002\u0002\u0002\u02a5\u02a7\u0007\b\u0002\u0002',
+  '\u02a6\u02a5\u0003\u0002\u0002\u0002\u02a6\u02a7\u0003\u0002\u0002\u0002',
+  '\u02a7?\u0003\u0002\u0002\u0002\u02a8\u02ad\u0005\u0194\u00cb\u0002',
+  '\u02a9\u02aa\u0007\u0005\u0002\u0002\u02aa\u02ac\u0005\u0194\u00cb\u0002',
+  '\u02ab\u02a9\u0003\u0002\u0002\u0002\u02ac\u02af\u0003\u0002\u0002\u0002',
+  '\u02ad\u02ab\u0003\u0002\u0002\u0002\u02ad\u02ae\u0003\u0002\u0002\u0002',
+  '\u02aeA\u0003\u0002\u0002\u0002\u02af\u02ad\u0003\u0002\u0002\u0002',
+  '\u02b0\u02b1\u0005D#\u0002\u02b1\u02b2\u0005R*\u0002\u02b2C\u0003\u0002',
+  '\u0002\u0002\u02b3\u02b5\u0005F$\u0002\u02b4\u02b6\u0007\u0099\u0002',
+  '\u0002\u02b5\u02b4\u0003\u0002\u0002\u0002\u02b5\u02b6\u0003\u0002\u0002',
+  '\u0002\u02b6\u02b8\u0003\u0002\u0002\u0002\u02b7\u02b3\u0003\u0002\u0002',
+  '\u0002\u02b8\u02bb\u0003\u0002\u0002\u0002\u02b9\u02b7\u0003\u0002\u0002',
+  '\u0002\u02b9\u02ba\u0003\u0002\u0002\u0002\u02baE\u0003\u0002\u0002',
+  '\u0002\u02bb\u02b9\u0003\u0002\u0002\u0002\u02bc\u02c0\u0005H%\u0002',
+  "\u02bd\u02c0\u0005L'\u0002\u02be\u02c0\u0005N(\u0002\u02bf\u02bc\u0003",
+  '\u0002\u0002\u0002\u02bf\u02bd\u0003\u0002\u0002\u0002\u02bf\u02be\u0003',
+  '\u0002\u0002\u0002\u02c0G\u0003\u0002\u0002\u0002\u02c1\u02c4\u0007',
+  '8\u0002\u0002\u02c2\u02c3\u0007\u0099\u0002\u0002\u02c3\u02c5\u0005',
+  'J&\u0002\u02c4\u02c2\u0003\u0002\u0002\u0002\u02c4\u02c5\u0003\u0002',
+  '\u0002\u0002\u02c5\u02ca\u0003\u0002\u0002\u0002\u02c6\u02c7\u0007\u0099',
+  '\u0002\u0002\u02c7\u02c9\u0005P)\u0002\u02c8\u02c6\u0003\u0002\u0002',
+  '\u0002\u02c9\u02cc\u0003\u0002\u0002\u0002\u02ca\u02c8\u0003\u0002\u0002',
+  '\u0002\u02ca\u02cb\u0003\u0002\u0002\u0002\u02cbI\u0003\u0002\u0002',
+  '\u0002\u02cc\u02ca\u0003\u0002\u0002\u0002\u02cd\u02ce\u0007\u0094\u0002',
+  '\u0002\u02ceK\u0003\u0002\u0002\u0002\u02cf\u02d0\u00079\u0002\u0002',
+  '\u02d0M\u0003\u0002\u0002\u0002\u02d1\u02d2\u0007:\u0002\u0002\u02d2',
+  'O\u0003\u0002\u0002\u0002\u02d3\u02d5\u0005\u0194\u00cb\u0002\u02d4',
+  '\u02d6\u0007\u0099\u0002\u0002\u02d5\u02d4\u0003\u0002\u0002\u0002\u02d5',
+  '\u02d6\u0003\u0002\u0002\u0002\u02d6\u02d7\u0003\u0002\u0002\u0002\u02d7',
+  '\u02d9\u0007\u000e\u0002\u0002\u02d8\u02da\u0007\u0099\u0002\u0002\u02d9',
+  '\u02d8\u0003\u0002\u0002\u0002\u02d9\u02da\u0003\u0002\u0002\u0002\u02da',
+  '\u02db\u0003\u0002\u0002\u0002\u02db\u02dc\u0005\u0194\u00cb\u0002\u02dc',
+  'Q\u0003\u0002\u0002\u0002\u02dd\u02e0\u0005d3\u0002\u02de\u02e0\u0005',
+  'T+\u0002\u02df\u02dd\u0003\u0002\u0002\u0002\u02df\u02de\u0003\u0002',
+  '\u0002\u0002\u02e0S\u0003\u0002\u0002\u0002\u02e1\u02e4\u0005V,\u0002',
+  '\u02e2\u02e4\u0005X-\u0002\u02e3\u02e1\u0003\u0002\u0002\u0002\u02e3',
+  '\u02e2\u0003\u0002\u0002\u0002\u02e4U\u0003\u0002\u0002\u0002\u02e5',
+  '\u02ec\u0005Z.\u0002\u02e6\u02e8\u0007\u0099\u0002\u0002\u02e7\u02e6',
+  '\u0003\u0002\u0002\u0002\u02e7\u02e8\u0003\u0002\u0002\u0002\u02e8\u02e9',
+  '\u0003\u0002\u0002\u0002\u02e9\u02eb\u0005`1\u0002\u02ea\u02e7\u0003',
+  '\u0002\u0002\u0002\u02eb\u02ee\u0003\u0002\u0002\u0002\u02ec\u02ea\u0003',
+  '\u0002\u0002\u0002\u02ec\u02ed\u0003\u0002\u0002\u0002\u02edW\u0003',
+  '\u0002\u0002\u0002\u02ee\u02ec\u0003\u0002\u0002\u0002\u02ef\u02f1\u0005',
+  '\\/\u0002\u02f0\u02f2\u0007\u0099\u0002\u0002\u02f1\u02f0\u0003\u0002',
+  '\u0002\u0002\u02f1\u02f2\u0003\u0002\u0002\u0002\u02f2\u02f3\u0003\u0002',
+  '\u0002\u0002\u02f3\u02f4\u0005^0\u0002\u02f4Y\u0003\u0002\u0002\u0002',
+  '\u02f5\u02fc\u0005b2\u0002\u02f6\u02f8\u0007\u0099\u0002\u0002\u02f7',
+  '\u02f6\u0003\u0002\u0002\u0002\u02f7\u02f8\u0003\u0002\u0002\u0002\u02f8',
+  '\u02f9\u0003\u0002\u0002\u0002\u02f9\u02fb\u0005b2\u0002\u02fa\u02f7',
+  '\u0003\u0002\u0002\u0002\u02fb\u02fe\u0003\u0002\u0002\u0002\u02fc\u02fa',
+  '\u0003\u0002\u0002\u0002\u02fc\u02fd\u0003\u0002\u0002\u0002\u02fd[',
+  '\u0003\u0002\u0002\u0002\u02fe\u02fc\u0003\u0002\u0002\u0002\u02ff\u0300',
+  '\u0007;\u0002\u0002\u0300\u0301\u0007\u0099\u0002\u0002\u0301\u0302',
+  '\u0007<\u0002\u0002\u0302\u0303\u0007\u0099\u0002\u0002\u0303\u0306',
+  '\u0007=\u0002\u0002\u0304\u0305\u0007\u0099\u0002\u0002\u0305\u0307',
+  '\u0005\u0188\u00c5\u0002\u0306\u0304\u0003\u0002\u0002\u0002\u0306\u0307',
+  '\u0003\u0002\u0002\u0002\u0307]\u0003\u0002\u0002\u0002\u0308\u030f',
+  '\u0005\u0086D\u0002\u0309\u030b\u0007\u0099\u0002\u0002\u030a\u0309',
+  '\u0003\u0002\u0002\u0002\u030a\u030b\u0003\u0002\u0002\u0002\u030b\u030c',
+  '\u0003\u0002\u0002\u0002\u030c\u030e\u0005b2\u0002\u030d\u030a\u0003',
+  '\u0002\u0002\u0002\u030e\u0311\u0003\u0002\u0002\u0002\u030f\u030d\u0003',
+  '\u0002\u0002\u0002\u030f\u0310\u0003\u0002\u0002\u0002\u0310_\u0003',
+  '\u0002\u0002\u0002\u0311\u030f\u0003\u0002\u0002\u0002\u0312\u0313\u0007',
+  '>\u0002\u0002\u0313\u0314\u0007\u0099\u0002\u0002\u0314\u0316\u0007',
+  '?\u0002\u0002\u0315\u0317\u0007\u0099\u0002\u0002\u0316\u0315\u0003',
+  '\u0002\u0002\u0002\u0316\u0317\u0003\u0002\u0002\u0002\u0317\u0318\u0003',
+  '\u0002\u0002\u0002\u0318\u031f\u0005Z.\u0002\u0319\u031b\u0007>\u0002',
+  '\u0002\u031a\u031c\u0007\u0099\u0002\u0002\u031b\u031a\u0003\u0002\u0002',
+  '\u0002\u031b\u031c\u0003\u0002\u0002\u0002\u031c\u031d\u0003\u0002\u0002',
+  '\u0002\u031d\u031f\u0005Z.\u0002\u031e\u0312\u0003\u0002\u0002\u0002',
+  '\u031e\u0319\u0003\u0002\u0002\u0002\u031fa\u0003\u0002\u0002\u0002',
+  '\u0320\u032f\u0005\u0086D\u0002\u0321\u032f\u0005\u00c6d\u0002\u0322',
+  '\u032f\u0005\u0088E\u0002\u0323\u032f\u0005\u008aF\u0002\u0324\u032f',
+  '\u0005\u008cG\u0002\u0325\u032f\u0005\u0090I\u0002\u0326\u032f\u0005',
+  '\u0092J\u0002\u0327\u032f\u0005\u0094K\u0002\u0328\u032f\u0005\u0098',
+  'M\u0002\u0329\u032f\u0005\u009aN\u0002\u032a\u032f\u0005\u009eP\u0002',
+  '\u032b\u032f\u0005\u00a0Q\u0002\u032c\u032f\u0005\u00a2R\u0002\u032d',
+  '\u032f\u0005\u00aaV\u0002\u032e\u0320\u0003\u0002\u0002\u0002\u032e',
+  '\u0321\u0003\u0002\u0002\u0002\u032e\u0322\u0003\u0002\u0002\u0002\u032e',
+  '\u0323\u0003\u0002\u0002\u0002\u032e\u0324\u0003\u0002\u0002\u0002\u032e',
+  '\u0325\u0003\u0002\u0002\u0002\u032e\u0326\u0003\u0002\u0002\u0002\u032e',
+  '\u0327\u0003\u0002\u0002\u0002\u032e\u0328\u0003\u0002\u0002\u0002\u032e',
+  '\u0329\u0003\u0002\u0002\u0002\u032e\u032a\u0003\u0002\u0002\u0002\u032e',
+  '\u032b\u0003\u0002\u0002\u0002\u032e\u032c\u0003\u0002\u0002\u0002\u032e',
+  '\u032d\u0003\u0002\u0002\u0002\u032fc\u0003\u0002\u0002\u0002\u0330',
+  '\u033b\u0005n8\u0002\u0331\u033b\u0005x=\u0002\u0332\u033b\u0005f4\u0002',
+  '\u0333\u033b\u0005p9\u0002\u0334\u033b\u0005h5\u0002\u0335\u033b\u0005',
+  'r:\u0002\u0336\u033b\u0005j6\u0002\u0337\u033b\u0005t;\u0002\u0338\u033b',
+  '\u0005l7\u0002\u0339\u033b\u0005v<\u0002\u033a\u0330\u0003\u0002\u0002',
+  '\u0002\u033a\u0331\u0003\u0002\u0002\u0002\u033a\u0332\u0003\u0002\u0002',
+  '\u0002\u033a\u0333\u0003\u0002\u0002\u0002\u033a\u0334\u0003\u0002\u0002',
+  '\u0002\u033a\u0335\u0003\u0002\u0002\u0002\u033a\u0336\u0003\u0002\u0002',
+  '\u0002\u033a\u0337\u0003\u0002\u0002\u0002\u033a\u0338\u0003\u0002\u0002',
+  '\u0002\u033a\u0339\u0003\u0002\u0002\u0002\u033be\u0003\u0002\u0002',
+  '\u0002\u033c\u033d\u0007@\u0002\u0002\u033d\u033e\u0007\u0099\u0002',
+  '\u0002\u033e\u033f\u0005|?\u0002\u033fg\u0003\u0002\u0002\u0002\u0340',
+  '\u0341\u0007@\u0002\u0002\u0341\u0342\u0007\u0099\u0002\u0002\u0342',
+  '\u0343\u0005~@\u0002\u0343i\u0003\u0002\u0002\u0002\u0344\u0345\u0007',
+  '@\u0002\u0002\u0345\u0346\u0007\u0099\u0002\u0002\u0346\u0347\u0005',
+  '\u0080A\u0002\u0347k\u0003\u0002\u0002\u0002\u0348\u0349\u0007@\u0002',
+  '\u0002\u0349\u034a\u0007\u0099\u0002\u0002\u034a\u034b\u0005\u0082B',
+  '\u0002\u034bm\u0003\u0002\u0002\u0002\u034c\u034d\u0007@\u0002\u0002',
+  '\u034d\u034e\u0007\u0099\u0002\u0002\u034e\u034f\u0005z>\u0002\u034f',
+  'o\u0003\u0002\u0002\u0002\u0350\u0351\u0007A\u0002\u0002\u0351\u0352',
+  '\u0007\u0099\u0002\u0002\u0352\u0353\u0005|?\u0002\u0353q\u0003\u0002',
+  '\u0002\u0002\u0354\u0355\u0007A\u0002\u0002\u0355\u0356\u0007\u0099',
+  '\u0002\u0002\u0356\u0357\u0005~@\u0002\u0357s\u0003\u0002\u0002\u0002',
+  '\u0358\u0359\u0007A\u0002\u0002\u0359\u035a\u0007\u0099\u0002\u0002',
+  '\u035a\u035b\u0005\u0080A\u0002\u035bu\u0003\u0002\u0002\u0002\u035c',
+  '\u035d\u0007A\u0002\u0002\u035d\u035e\u0007\u0099\u0002\u0002\u035e',
+  '\u035f\u0005\u0082B\u0002\u035fw\u0003\u0002\u0002\u0002\u0360\u0361',
+  '\u0007A\u0002\u0002\u0361\u0362\u0007\u0099\u0002\u0002\u0362\u0363',
+  '\u0005z>\u0002\u0363y\u0003\u0002\u0002\u0002\u0364\u0365\u0007B\u0002',
+  '\u0002\u0365\u0366\u0007\u0099\u0002\u0002\u0366\u0368\u0007C\u0002',
+  '\u0002\u0367\u0369\u0007\u0099\u0002\u0002\u0368\u0367\u0003\u0002\u0002',
+  '\u0002\u0368\u0369\u0003\u0002\u0002\u0002\u0369\u036a\u0003\u0002\u0002',
+  '\u0002\u036a\u036c\u0005\u00fa~\u0002\u036b\u036d\u0007\u0099\u0002',
+  '\u0002\u036c\u036b\u0003\u0002\u0002\u0002\u036c\u036d\u0003\u0002\u0002',
+  '\u0002\u036d\u036e\u0003\u0002\u0002\u0002\u036e\u0370\u0007\u0015\u0002',
+  '\u0002\u036f\u0371\u0007\u0099\u0002\u0002\u0370\u036f\u0003\u0002\u0002',
+  '\u0002\u0370\u0371\u0003\u0002\u0002\u0002\u0371\u0372\u0003\u0002\u0002',
+  '\u0002\u0372\u0374\u0005\u0184\u00c3\u0002\u0373\u0375\u0007\u0099\u0002',
+  '\u0002\u0374\u0373\u0003\u0002\u0002\u0002\u0374\u0375\u0003\u0002\u0002',
+  '\u0002\u0375\u0376\u0003\u0002\u0002\u0002\u0376\u0377\u0007\u0016\u0002',
+  '\u0002\u0377{\u0003\u0002\u0002\u0002\u0378\u0379\u0007D\u0002\u0002',
+  '\u0379\u037a\u0007\u0099\u0002\u0002\u037a\u037c\u0007C\u0002\u0002',
+  '\u037b\u037d\u0007\u0099\u0002\u0002\u037c\u037b\u0003\u0002\u0002\u0002',
+  '\u037c\u037d\u0003\u0002\u0002\u0002\u037d\u037e\u0003\u0002\u0002\u0002',
+  '\u037e\u0380\u0007\u0015\u0002\u0002\u037f\u0381\u0007\u0099\u0002\u0002',
+  '\u0380\u037f\u0003\u0002\u0002\u0002\u0380\u0381\u0003\u0002\u0002\u0002',
+  '\u0381\u0382\u0003\u0002\u0002\u0002\u0382\u0383\u0005\u0166\u00b4\u0002',
+  '\u0383\u0385\u0005\u00fa~\u0002\u0384\u0386\u0007\u0099\u0002\u0002',
+  '\u0385\u0384\u0003\u0002\u0002\u0002\u0385\u0386\u0003\u0002\u0002\u0002',
+  '\u0386\u0387\u0003\u0002\u0002\u0002\u0387\u0389\u0007\u0016\u0002\u0002',
+  '\u0388\u038a\u0007\u0099\u0002\u0002\u0389\u0388\u0003\u0002\u0002\u0002',
+  '\u0389\u038a\u0003\u0002\u0002\u0002\u038a\u038b\u0003\u0002\u0002\u0002',
+  '\u038b\u038c\u0007E\u0002\u0002\u038c\u038d\u0007\u0099\u0002\u0002',
+  '\u038d\u038e\u0005\u0182\u00c2\u0002\u038e\u038f\u0007\u0099\u0002\u0002',
+  '\u038f\u0390\u0007F\u0002\u0002\u0390\u0391\u0007\u0099\u0002\u0002',
+  '\u0391\u0392\u0007G\u0002\u0002\u0392}\u0003\u0002\u0002\u0002\u0393',
+  '\u0394\u0007D\u0002\u0002\u0394\u0395\u0007\u0099\u0002\u0002\u0395',
+  '\u0397\u0007C\u0002\u0002\u0396\u0398\u0007\u0099\u0002\u0002\u0397',
+  '\u0396\u0003\u0002\u0002\u0002\u0397\u0398\u0003\u0002\u0002\u0002\u0398',
+  '\u0399\u0003\u0002\u0002\u0002\u0399\u039b\u0007\u0015\u0002\u0002\u039a',
+  '\u039c\u0007\u0099\u0002\u0002\u039b\u039a\u0003\u0002\u0002\u0002\u039b',
+  '\u039c\u0003\u0002\u0002\u0002\u039c\u039d\u0003\u0002\u0002\u0002\u039d',
+  '\u039e\u0005\u0166\u00b4\u0002\u039e\u03a0\u0005\u00fa~\u0002\u039f',
+  '\u03a1\u0007\u0099\u0002\u0002\u03a0\u039f\u0003\u0002\u0002\u0002\u03a0',
+  '\u03a1\u0003\u0002\u0002\u0002\u03a1\u03a2\u0003\u0002\u0002\u0002\u03a2',
+  '\u03a4\u0007\u0016\u0002\u0002\u03a3\u03a5\u0007\u0099\u0002\u0002\u03a4',
+  '\u03a3\u0003\u0002\u0002\u0002\u03a4\u03a5\u0003\u0002\u0002\u0002\u03a5',
+  '\u03a6\u0003\u0002\u0002\u0002\u03a6\u03a7\u0007E\u0002\u0002\u03a7',
+  '\u03a8\u0007\u0099\u0002\u0002\u03a8\u03aa\u0007\u0015\u0002\u0002\u03a9',
+  '\u03ab\u0007\u0099\u0002\u0002\u03aa\u03a9\u0003\u0002\u0002\u0002\u03aa',
+  '\u03ab\u0003\u0002\u0002\u0002\u03ab\u03ac\u0003\u0002\u0002\u0002\u03ac',
+  '\u03ae\u0005\u0180\u00c1\u0002\u03ad\u03af\u0007\u0099\u0002\u0002\u03ae',
+  '\u03ad\u0003\u0002\u0002\u0002\u03ae\u03af\u0003\u0002\u0002\u0002\u03af',
+  '\u03b0\u0003\u0002\u0002\u0002\u03b0\u03b1\u0007\u0016\u0002\u0002\u03b1',
+  '\u03b2\u0007\u0099\u0002\u0002\u03b2\u03b3\u0007F\u0002\u0002\u03b3',
+  '\u03b4\u0007\u0099\u0002\u0002\u03b4\u03b5\u0007g\u0002\u0002\u03b5',
+  '\u03b6\u0007\u0099\u0002\u0002\u03b6\u03b7\u0007\u0085\u0002\u0002\u03b7',
+  '\u007f\u0003\u0002\u0002\u0002\u03b8\u03b9\u0007D\u0002\u0002\u03b9',
+  '\u03ba\u0007\u0099\u0002\u0002\u03ba\u03bc\u0007C\u0002\u0002\u03bb',
+  '\u03bd\u0007\u0099\u0002\u0002\u03bc\u03bb\u0003\u0002\u0002\u0002\u03bc',
+  '\u03bd\u0003\u0002\u0002\u0002\u03bd\u03be\u0003\u0002\u0002\u0002\u03be',
+  '\u03bf\u0007\u0015\u0002\u0002\u03bf\u03c0\u0005\u0166\u00b4\u0002\u03c0',
+  '\u03c1\u0005\u00fa~\u0002\u03c1\u03c3\u0007\u0016\u0002\u0002\u03c2',
+  '\u03c4\u0007\u0099\u0002\u0002\u03c3\u03c2\u0003\u0002\u0002\u0002\u03c3',
+  '\u03c4\u0003\u0002\u0002\u0002\u03c4\u03c5\u0003\u0002\u0002\u0002\u03c5',
+  '\u03c6\u0007E\u0002\u0002\u03c6\u03c7\u0007\u0099\u0002\u0002\u03c7',
+  '\u03c9\u0007H\u0002\u0002\u03c8\u03ca\u0007\u0099\u0002\u0002\u03c9',
+  '\u03c8\u0003\u0002\u0002\u0002\u03c9\u03ca\u0003\u0002\u0002\u0002\u03ca',
+  '\u03cb\u0003\u0002\u0002\u0002\u03cb\u03cc\u0007\u0015\u0002\u0002\u03cc',
+  '\u03cd\u0005\u0182\u00c2\u0002\u03cd\u03ce\u0007\u0016\u0002\u0002\u03ce',
+  '\u0081\u0003\u0002\u0002\u0002\u03cf\u03d0\u0007D\u0002\u0002\u03d0',
+  '\u03d1\u0007\u0099\u0002\u0002\u03d1\u03d3\u0007C\u0002\u0002\u03d2',
+  '\u03d4\u0007\u0099\u0002\u0002\u03d3\u03d2\u0003\u0002\u0002\u0002\u03d3',
+  '\u03d4\u0003\u0002\u0002\u0002\u03d4\u03d5\u0003\u0002\u0002\u0002\u03d5',
+  '\u03d7\u0005\u0084C\u0002\u03d6\u03d8\u0007\u0099\u0002\u0002\u03d7',
+  '\u03d6\u0003\u0002\u0002\u0002\u03d7\u03d8\u0003\u0002\u0002\u0002\u03d8',
+  '\u03d9\u0003\u0002\u0002\u0002\u03d9\u03da\u0007E\u0002\u0002\u03da',
+  '\u03db\u0007\u0099\u0002\u0002\u03db\u03dd\u0007H\u0002\u0002\u03dc',
+  '\u03de\u0007\u0099\u0002\u0002\u03dd\u03dc\u0003\u0002\u0002\u0002\u03dd',
+  '\u03de\u0003\u0002\u0002\u0002\u03de\u03df\u0003\u0002\u0002\u0002\u03df',
+  '\u03e0\u0007\u0015\u0002\u0002\u03e0\u03e1\u0005\u0182\u00c2\u0002\u03e1',
+  '\u03e2\u0007\u0016\u0002\u0002\u03e2\u0083\u0003\u0002\u0002\u0002\u03e3',
+  '\u03e5\u0007\u0015\u0002\u0002\u03e4\u03e6\u0007\u0099\u0002\u0002\u03e5',
+  '\u03e4\u0003\u0002\u0002\u0002\u03e5\u03e6\u0003\u0002\u0002\u0002\u03e6',
+  '\u03e7\u0003\u0002\u0002\u0002\u03e7\u03e8\u0007\u0016\u0002\u0002\u03e8',
+  '\u03e9\u0005\u0192\u00ca\u0002\u03e9\u03ea\u0007\u0013\u0002\u0002\u03ea',
+  '\u03eb\u0005\u0166\u00b4\u0002\u03eb\u03ec\u0005\u00f0y\u0002\u03ec',
+  '\u03ed\u0007\u0014\u0002\u0002\u03ed\u03ee\u0005\u0192\u00ca\u0002\u03ee',
+  '\u03f0\u0007\u0015\u0002\u0002\u03ef\u03f1\u0007\u0099\u0002\u0002\u03f0',
+  '\u03ef\u0003\u0002\u0002\u0002\u03f0\u03f1\u0003\u0002\u0002\u0002\u03f1',
+  '\u03f2\u0003\u0002\u0002\u0002\u03f2\u03f3\u0007\u0016\u0002\u0002\u03f3',
+  '\u0419\u0003\u0002\u0002\u0002\u03f4\u03f6\u0007\u0015\u0002\u0002\u03f5',
+  '\u03f7\u0007\u0099\u0002\u0002\u03f6\u03f5\u0003\u0002\u0002\u0002\u03f6',
+  '\u03f7\u0003\u0002\u0002\u0002\u03f7\u03f8\u0003\u0002\u0002\u0002\u03f8',
+  '\u03f9\u0007\u0016\u0002\u0002\u03f9\u03fa\u0005\u0192\u00ca\u0002\u03fa',
+  '\u03fb\u0007\u0013\u0002\u0002\u03fb\u03fc\u0005\u0166\u00b4\u0002\u03fc',
+  '\u03fd\u0005\u00f0y\u0002\u03fd\u03fe\u0007\u0014\u0002\u0002\u03fe',
+  '\u03ff\u0005\u0192\u00ca\u0002\u03ff\u0400\u0005\u0190\u00c9\u0002\u0400',
+  '\u0402\u0007\u0015\u0002\u0002\u0401\u0403\u0007\u0099\u0002\u0002\u0402',
+  '\u0401\u0003\u0002\u0002\u0002\u0402\u0403\u0003\u0002\u0002\u0002\u0403',
+  '\u0404\u0003\u0002\u0002\u0002\u0404\u0405\u0007\u0016\u0002\u0002\u0405',
+  '\u0419\u0003\u0002\u0002\u0002\u0406\u0408\u0007\u0015\u0002\u0002\u0407',
+  '\u0409\u0007\u0099\u0002\u0002\u0408\u0407\u0003\u0002\u0002\u0002\u0408',
+  '\u0409\u0003\u0002\u0002\u0002\u0409\u040a\u0003\u0002\u0002\u0002\u040a',
+  '\u040b\u0007\u0016\u0002\u0002\u040b\u040c\u0005\u018e\u00c8\u0002\u040c',
+  '\u040d\u0005\u0192\u00ca\u0002\u040d\u040e\u0007\u0013\u0002\u0002\u040e',
+  '\u040f\u0005\u0166\u00b4\u0002\u040f\u0410\u0005\u00f0y\u0002\u0410',
+  '\u0411\u0007\u0014\u0002\u0002\u0411\u0412\u0005\u0192\u00ca\u0002\u0412',
+  '\u0414\u0007\u0015\u0002\u0002\u0413\u0415\u0007\u0099\u0002\u0002\u0414',
+  '\u0413\u0003\u0002\u0002\u0002\u0414\u0415\u0003\u0002\u0002\u0002\u0415',
+  '\u0416\u0003\u0002\u0002\u0002\u0416\u0417\u0007\u0016\u0002\u0002\u0417',
+  '\u0419\u0003\u0002\u0002\u0002\u0418\u03e3\u0003\u0002\u0002\u0002\u0418',
+  '\u03f4\u0003\u0002\u0002\u0002\u0418\u0406\u0003\u0002\u0002\u0002\u0419',
+  '\u0085\u0003\u0002\u0002\u0002\u041a\u041b\u0007I\u0002\u0002\u041b',
+  '\u041c\u0007\u0099\u0002\u0002\u041c\u041d\u0007J\u0002\u0002\u041d',
+  '\u0422\u0007\u0099\u0002\u0002\u041e\u041f\u0007K\u0002\u0002\u041f',
+  '\u0420\u0007\u0099\u0002\u0002\u0420\u0421\u0007L\u0002\u0002\u0421',
+  '\u0423\u0007\u0099\u0002\u0002\u0422\u041e\u0003\u0002\u0002\u0002\u0422',
+  '\u0423\u0003\u0002\u0002\u0002\u0423\u0424\u0003\u0002\u0002\u0002\u0424',
+  '\u0425\u0007M\u0002\u0002\u0425\u0426\u0007\u0099\u0002\u0002\u0426',
+  '\u0427\u0005\u0102\u0082\u0002\u0427\u0428\u0007\u0099\u0002\u0002\u0428',
+  '\u0429\u0007N\u0002\u0002\u0429\u042a\u0007\u0099\u0002\u0002\u042a',
+  '\u042b\u0005\u0166\u00b4\u0002\u042b\u042f\u0007\u0099\u0002\u0002\u042c',
+  '\u042d\u0007O\u0002\u0002\u042d\u042e\u0007\u0099\u0002\u0002\u042e',
+  '\u0430\u0007\u0086\u0002\u0002\u042f\u042c\u0003\u0002\u0002\u0002\u042f',
+  '\u0430\u0003\u0002\u0002\u0002\u0430\u0087\u0003\u0002\u0002\u0002\u0431',
+  '\u0432\u0007P\u0002\u0002\u0432\u0434\u0007\u0099\u0002\u0002\u0433',
+  '\u0431\u0003\u0002\u0002\u0002\u0433\u0434\u0003\u0002\u0002\u0002\u0434',
+  '\u0435\u0003\u0002\u0002\u0002\u0435\u0437\u0007Q\u0002\u0002\u0436',
+  '\u0438\u0007\u0099\u0002\u0002\u0437\u0436\u0003\u0002\u0002\u0002\u0437',
+  '\u0438\u0003\u0002\u0002\u0002\u0438\u0439\u0003\u0002\u0002\u0002\u0439',
+  '\u043d\u0005\u00dan\u0002\u043a\u043c\u0005\u00c4c\u0002\u043b\u043a',
+  '\u0003\u0002\u0002\u0002\u043c\u043f\u0003\u0002\u0002\u0002\u043d\u043b',
+  '\u0003\u0002\u0002\u0002\u043d\u043e\u0003\u0002\u0002\u0002\u043e\u0444',
+  '\u0003\u0002\u0002\u0002\u043f\u043d\u0003\u0002\u0002\u0002\u0440\u0442',
+  '\u0007\u0099\u0002\u0002\u0441\u0440\u0003\u0002\u0002\u0002\u0441\u0442',
+  '\u0003\u0002\u0002\u0002\u0442\u0443\u0003\u0002\u0002\u0002\u0443\u0445',
+  '\u0005\u00d8m\u0002\u0444\u0441\u0003\u0002\u0002\u0002\u0444\u0445',
+  '\u0003\u0002\u0002\u0002\u0445\u0089\u0003\u0002\u0002\u0002\u0446\u0448',
+  '\u0007R\u0002\u0002\u0447\u0449\u0007\u0099\u0002\u0002\u0448\u0447',
+  '\u0003\u0002\u0002\u0002\u0448\u0449\u0003\u0002\u0002\u0002\u0449\u044a',
+  '\u0003\u0002\u0002\u0002\u044a\u044b\u0005\u0102\u0082\u0002\u044b\u044c',
+  '\u0007\u0099\u0002\u0002\u044c\u044d\u0007N\u0002\u0002\u044d\u044e',
+  '\u0007\u0099\u0002\u0002\u044e\u044f\u0005\u0166\u00b4\u0002\u044f\u008b',
+  '\u0003\u0002\u0002\u0002\u0450\u0452\u0007S\u0002\u0002\u0451\u0453',
+  '\u0007\u0099\u0002\u0002\u0452\u0451\u0003\u0002\u0002\u0002\u0452\u0453',
+  '\u0003\u0002\u0002\u0002\u0453\u0454\u0003\u0002\u0002\u0002\u0454\u0459',
+  '\u0005\u00dco\u0002\u0455\u0456\u0007\u0099\u0002\u0002\u0456\u0458',
+  '\u0005\u008eH\u0002\u0457\u0455\u0003\u0002\u0002\u0002\u0458\u045b',
+  '\u0003\u0002\u0002\u0002\u0459\u0457\u0003\u0002\u0002\u0002\u0459\u045a',
+  '\u0003\u0002\u0002\u0002\u045a\u008d\u0003\u0002\u0002\u0002\u045b\u0459',
+  '\u0003\u0002\u0002\u0002\u045c\u045d\u0007C\u0002\u0002\u045d\u045e',
+  '\u0007\u0099\u0002\u0002\u045e\u045f\u0007Q\u0002\u0002\u045f\u0460',
+  '\u0007\u0099\u0002\u0002\u0460\u0467\u0005\u0094K\u0002\u0461\u0462',
+  '\u0007C\u0002\u0002\u0462\u0463\u0007\u0099\u0002\u0002\u0463\u0464',
+  '\u0007@\u0002\u0002\u0464\u0465\u0007\u0099\u0002\u0002\u0465\u0467',
+  '\u0005\u0094K\u0002\u0466\u045c\u0003\u0002\u0002\u0002\u0466\u0461',
+  '\u0003\u0002\u0002\u0002\u0467\u008f\u0003\u0002\u0002\u0002\u0468\u046a',
+  '\u0007@\u0002\u0002\u0469\u046b\u0007\u0099\u0002\u0002\u046a\u0469',
+  '\u0003\u0002\u0002\u0002\u046a\u046b\u0003\u0002\u0002\u0002\u046b\u046c',
+  '\u0003\u0002\u0002\u0002\u046c\u046d\u0005\u00dan\u0002\u046d\u0091',
+  '\u0003\u0002\u0002\u0002\u046e\u046f\u0007@\u0002\u0002\u046f\u0470',
+  '\u0007\u0099\u0002\u0002\u0470\u0472\u0007G\u0002\u0002\u0471\u0473',
+  '\u0007\u0099\u0002\u0002\u0472\u0471\u0003\u0002\u0002\u0002\u0472\u0473',
+  '\u0003\u0002\u0002\u0002\u0473\u0474\u0003\u0002\u0002\u0002\u0474\u0475',
+  '\u0005\u00dan\u0002\u0475\u0093\u0003\u0002\u0002\u0002\u0476\u0478',
+  '\u0007T\u0002\u0002\u0477\u0479\u0007\u0099\u0002\u0002\u0478\u0477',
+  '\u0003\u0002\u0002\u0002\u0478\u0479\u0003\u0002\u0002\u0002\u0479\u047a',
+  '\u0003\u0002\u0002\u0002\u047a\u0485\u0005\u0096L\u0002\u047b\u047d',
+  '\u0007\u0099\u0002\u0002\u047c\u047b\u0003\u0002\u0002\u0002\u047c\u047d',
+  '\u0003\u0002\u0002\u0002\u047d\u047e\u0003\u0002\u0002\u0002\u047e\u0480',
+  '\u0007\u0011\u0002\u0002\u047f\u0481\u0007\u0099\u0002\u0002\u0480\u047f',
+  '\u0003\u0002\u0002\u0002\u0480\u0481\u0003\u0002\u0002\u0002\u0481\u0482',
+  '\u0003\u0002\u0002\u0002\u0482\u0484\u0005\u0096L\u0002\u0483\u047c',
+  '\u0003\u0002\u0002\u0002\u0484\u0487\u0003\u0002\u0002\u0002\u0485\u0483',
+  '\u0003\u0002\u0002\u0002\u0485\u0486\u0003\u0002\u0002\u0002\u0486\u0095',
+  '\u0003\u0002\u0002\u0002\u0487\u0485\u0003\u0002\u0002\u0002\u0488\u048a',
+  '\u0005\u0182\u00c2\u0002\u0489\u048b\u0007\u0099\u0002\u0002\u048a\u0489',
+  '\u0003\u0002\u0002\u0002\u048a\u048b\u0003\u0002\u0002\u0002\u048b\u048c',
+  '\u0003\u0002\u0002\u0002\u048c\u048e\u0007\u000e\u0002\u0002\u048d\u048f',
+  '\u0007\u0099\u0002\u0002\u048e\u048d\u0003\u0002\u0002\u0002\u048e\u048f',
+  '\u0003\u0002\u0002\u0002\u048f\u0490\u0003\u0002\u0002\u0002\u0490\u0491',
+  '\u0005\u0102\u0082\u0002\u0491\u04ad\u0003\u0002\u0002\u0002\u0492\u0494',
+  '\u0005\u0166\u00b4\u0002\u0493\u0495\u0007\u0099\u0002\u0002\u0494\u0493',
+  '\u0003\u0002\u0002\u0002\u0494\u0495\u0003\u0002\u0002\u0002\u0495\u0496',
+  '\u0003\u0002\u0002\u0002\u0496\u0498\u0007\u000e\u0002\u0002\u0497\u0499',
+  '\u0007\u0099\u0002\u0002\u0498\u0497\u0003\u0002\u0002\u0002\u0498\u0499',
+  '\u0003\u0002\u0002\u0002\u0499\u049a\u0003\u0002\u0002\u0002\u049a\u049b',
+  '\u0005\u0102\u0082\u0002\u049b\u04ad\u0003\u0002\u0002\u0002\u049c\u049e',
+  '\u0005\u0166\u00b4\u0002\u049d\u049f\u0007\u0099\u0002\u0002\u049e\u049d',
+  '\u0003\u0002\u0002\u0002\u049e\u049f\u0003\u0002\u0002\u0002\u049f\u04a0',
+  '\u0003\u0002\u0002\u0002\u04a0\u04a2\u0007\u0017\u0002\u0002\u04a1\u04a3',
+  '\u0007\u0099\u0002\u0002\u04a2\u04a1\u0003\u0002\u0002\u0002\u04a2\u04a3',
+  '\u0003\u0002\u0002\u0002\u04a3\u04a4\u0003\u0002\u0002\u0002\u04a4\u04a5',
+  '\u0005\u0102\u0082\u0002\u04a5\u04ad\u0003\u0002\u0002\u0002\u04a6\u04a8',
+  '\u0005\u0166\u00b4\u0002\u04a7\u04a9\u0007\u0099\u0002\u0002\u04a8\u04a7',
+  '\u0003\u0002\u0002\u0002\u04a8\u04a9\u0003\u0002\u0002\u0002\u04a9\u04aa',
+  '\u0003\u0002\u0002\u0002\u04aa\u04ab\u0005\u00f8}\u0002\u04ab\u04ad',
+  '\u0003\u0002\u0002\u0002\u04ac\u0488\u0003\u0002\u0002\u0002\u04ac\u0492',
+  '\u0003\u0002\u0002\u0002\u04ac\u049c\u0003\u0002\u0002\u0002\u04ac\u04a6',
+  '\u0003\u0002\u0002\u0002\u04ad\u0097\u0003\u0002\u0002\u0002\u04ae\u04af',
+  '\u0007U\u0002\u0002\u04af\u04b1\u0007\u0099\u0002\u0002\u04b0\u04ae',
+  '\u0003\u0002\u0002\u0002\u04b0\u04b1\u0003\u0002\u0002\u0002\u04b1\u04b2',
+  '\u0003\u0002\u0002\u0002\u04b2\u04b4\u0007V\u0002\u0002\u04b3\u04b5',
+  '\u0007\u0099\u0002\u0002\u04b4\u04b3\u0003\u0002\u0002\u0002\u04b4\u04b5',
+  '\u0003\u0002\u0002\u0002\u04b5\u04b6\u0003\u0002\u0002\u0002\u04b6\u04c1',
+  '\u0005\u0102\u0082\u0002\u04b7\u04b9\u0007\u0099\u0002\u0002\u04b8\u04b7',
+  '\u0003\u0002\u0002\u0002\u04b8\u04b9\u0003\u0002\u0002\u0002\u04b9\u04ba',
+  '\u0003\u0002\u0002\u0002\u04ba\u04bc\u0007\u0011\u0002\u0002\u04bb\u04bd',
+  '\u0007\u0099\u0002\u0002\u04bc\u04bb\u0003\u0002\u0002\u0002\u04bc\u04bd',
+  '\u0003\u0002\u0002\u0002\u04bd\u04be\u0003\u0002\u0002\u0002\u04be\u04c0',
+  '\u0005\u0102\u0082\u0002\u04bf\u04b8\u0003\u0002\u0002\u0002\u04c0\u04c3',
+  '\u0003\u0002\u0002\u0002\u04c1\u04bf\u0003\u0002\u0002\u0002\u04c1\u04c2',
+  '\u0003\u0002\u0002\u0002\u04c2\u0099\u0003\u0002\u0002\u0002\u04c3\u04c1',
+  '\u0003\u0002\u0002\u0002\u04c4\u04c5\u0007W\u0002\u0002\u04c5\u04c6',
+  '\u0007\u0099\u0002\u0002\u04c6\u04d1\u0005\u009cO\u0002\u04c7\u04c9',
+  '\u0007\u0099\u0002\u0002\u04c8\u04c7\u0003\u0002\u0002\u0002\u04c8\u04c9',
+  '\u0003\u0002\u0002\u0002\u04c9\u04ca\u0003\u0002\u0002\u0002\u04ca\u04cc',
+  '\u0007\u0011\u0002\u0002\u04cb\u04cd\u0007\u0099\u0002\u0002\u04cc\u04cb',
+  '\u0003\u0002\u0002\u0002\u04cc\u04cd\u0003\u0002\u0002\u0002\u04cd\u04ce',
+  '\u0003\u0002\u0002\u0002\u04ce\u04d0\u0005\u009cO\u0002\u04cf\u04c8',
+  '\u0003\u0002\u0002\u0002\u04d0\u04d3\u0003\u0002\u0002\u0002\u04d1\u04cf',
+  '\u0003\u0002\u0002\u0002\u04d1\u04d2\u0003\u0002\u0002\u0002\u04d2\u009b',
+  '\u0003\u0002\u0002\u0002\u04d3\u04d1\u0003\u0002\u0002\u0002\u04d4\u04d5',
+  '\u0005\u0166\u00b4\u0002\u04d5\u04d6\u0005\u00f8}\u0002\u04d6\u04d9',
+  '\u0003\u0002\u0002\u0002\u04d7\u04d9\u0005\u0182\u00c2\u0002\u04d8\u04d4',
+  '\u0003\u0002\u0002\u0002\u04d8\u04d7\u0003\u0002\u0002\u0002\u04d9\u009d',
+  '\u0003\u0002\u0002\u0002\u04da\u04dc\u0007X\u0002\u0002\u04db\u04dd',
+  '\u0007\u0099\u0002\u0002\u04dc\u04db\u0003\u0002\u0002\u0002\u04dc\u04dd',
+  '\u0003\u0002\u0002\u0002\u04dd\u04de\u0003\u0002\u0002\u0002\u04de\u04e0',
+  '\u0007\u0015\u0002\u0002\u04df\u04e1\u0007\u0099\u0002\u0002\u04e0\u04df',
+  '\u0003\u0002\u0002\u0002\u04e0\u04e1\u0003\u0002\u0002\u0002\u04e1\u04e2',
+  '\u0003\u0002\u0002\u0002\u04e2\u04e3\u0005\u0166\u00b4\u0002\u04e3\u04e4',
+  '\u0007\u0099\u0002\u0002\u04e4\u04e5\u0007Y\u0002\u0002\u04e5\u04e6',
+  '\u0007\u0099\u0002\u0002\u04e6\u04e8\u0005\u0102\u0082\u0002\u04e7\u04e9',
+  '\u0007\u0099\u0002\u0002\u04e8\u04e7\u0003\u0002\u0002\u0002\u04e8\u04e9',
+  '\u0003\u0002\u0002\u0002\u04e9\u04ea\u0003\u0002\u0002\u0002\u04ea\u04ed',
+  '\u0007\u0018\u0002\u0002\u04eb\u04ec\u0007\u0099\u0002\u0002\u04ec\u04ee',
+  '\u0005b2\u0002\u04ed\u04eb\u0003\u0002\u0002\u0002\u04ee\u04ef\u0003',
+  '\u0002\u0002\u0002\u04ef\u04ed\u0003\u0002\u0002\u0002\u04ef\u04f0\u0003',
+  '\u0002\u0002\u0002\u04f0\u04f2\u0003\u0002\u0002\u0002\u04f1\u04f3\u0007',
+  '\u0099\u0002\u0002\u04f2\u04f1\u0003\u0002\u0002\u0002\u04f2\u04f3\u0003',
+  '\u0002\u0002\u0002\u04f3\u04f4\u0003\u0002\u0002\u0002\u04f4\u04f5\u0007',
+  '\u0016\u0002\u0002\u04f5\u009f\u0003\u0002\u0002\u0002\u04f6\u04fb\u0007',
+  'K\u0002\u0002\u04f7\u04f9\u0007\u0099\u0002\u0002\u04f8\u04f7\u0003',
+  '\u0002\u0002\u0002\u04f8\u04f9\u0003\u0002\u0002\u0002\u04f9\u04fa\u0003',
+  '\u0002\u0002\u0002\u04fa\u04fc\u0007Z\u0002\u0002\u04fb\u04f8\u0003',
+  '\u0002\u0002\u0002\u04fb\u04fc\u0003\u0002\u0002\u0002\u04fc\u04fd\u0003',
+  '\u0002\u0002\u0002\u04fd\u04fe\u0007\u0099\u0002\u0002\u04fe\u0503\u0005',
+  '\u00a4S\u0002\u04ff\u0501\u0007\u0099\u0002\u0002\u0500\u04ff\u0003',
+  '\u0002\u0002\u0002\u0500\u0501\u0003\u0002\u0002\u0002\u0501\u0502\u0003',
+  '\u0002\u0002\u0002\u0502\u0504\u0005\u00d8m\u0002\u0503\u0500\u0003',
+  '\u0002\u0002\u0002\u0503\u0504\u0003\u0002\u0002\u0002\u0504\u00a1\u0003',
+  '\u0002\u0002\u0002\u0505\u050a\u0007[\u0002\u0002\u0506\u0508\u0007',
+  '\u0099\u0002\u0002\u0507\u0506\u0003\u0002\u0002\u0002\u0507\u0508\u0003',
+  '\u0002\u0002\u0002\u0508\u0509\u0003\u0002\u0002\u0002\u0509\u050b\u0007',
+  'Z\u0002\u0002\u050a\u0507\u0003\u0002\u0002\u0002\u050a\u050b\u0003',
+  '\u0002\u0002\u0002\u050b\u050d\u0003\u0002\u0002\u0002\u050c\u050e\u0007',
+  '\u0099\u0002\u0002\u050d\u050c\u0003\u0002\u0002\u0002\u050d\u050e\u0003',
+  '\u0002\u0002\u0002\u050e\u050f\u0003\u0002\u0002\u0002\u050f\u0510\u0005',
+  '\u00a4S\u0002\u0510\u00a3\u0003\u0002\u0002\u0002\u0511\u0514\u0005',
+  '\u00a6T\u0002\u0512\u0513\u0007\u0099\u0002\u0002\u0513\u0515\u0005',
+  '\u00bc_\u0002\u0514\u0512\u0003\u0002\u0002\u0002\u0514\u0515\u0003',
+  '\u0002\u0002\u0002\u0515\u0518\u0003\u0002\u0002\u0002\u0516\u0517\u0007',
+  '\u0099\u0002\u0002\u0517\u0519\u0005\u00be`\u0002\u0518\u0516\u0003',
+  '\u0002\u0002\u0002\u0518\u0519\u0003\u0002\u0002\u0002\u0519\u051c\u0003',
+  '\u0002\u0002\u0002\u051a\u051b\u0007\u0099\u0002\u0002\u051b\u051d\u0005',
+  '\u00c0a\u0002\u051c\u051a\u0003\u0002\u0002\u0002\u051c\u051d\u0003',
+  '\u0002\u0002\u0002\u051d\u00a5\u0003\u0002\u0002\u0002\u051e\u0529\u0007',
+  '\u0019\u0002\u0002\u051f\u0521\u0007\u0099\u0002\u0002\u0520\u051f\u0003',
+  '\u0002\u0002\u0002\u0520\u0521\u0003\u0002\u0002\u0002\u0521\u0522\u0003',
+  '\u0002\u0002\u0002\u0522\u0524\u0007\u0011\u0002\u0002\u0523\u0525\u0007',
+  '\u0099\u0002\u0002\u0524\u0523\u0003\u0002\u0002\u0002\u0524\u0525\u0003',
+  '\u0002\u0002\u0002\u0525\u0526\u0003\u0002\u0002\u0002\u0526\u0528\u0005',
+  '\u00a8U\u0002\u0527\u0520\u0003\u0002\u0002\u0002\u0528\u052b\u0003',
+  '\u0002\u0002\u0002\u0529\u0527\u0003\u0002\u0002\u0002\u0529\u052a\u0003',
+  '\u0002\u0002\u0002\u052a\u0542\u0003\u0002\u0002\u0002\u052b\u0529\u0003',
+  '\u0002\u0002\u0002\u052c\u0537\u0005\u00a8U\u0002\u052d\u052f\u0007',
+  '\u0099\u0002\u0002\u052e\u052d\u0003\u0002\u0002\u0002\u052e\u052f\u0003',
+  '\u0002\u0002\u0002\u052f\u0530\u0003\u0002\u0002\u0002\u0530\u0532\u0007',
+  '\u0011\u0002\u0002\u0531\u0533\u0007\u0099\u0002\u0002\u0532\u0531\u0003',
+  '\u0002\u0002\u0002\u0532\u0533\u0003\u0002\u0002\u0002\u0533\u0534\u0003',
+  '\u0002\u0002\u0002\u0534\u0536\u0005\u00a8U\u0002\u0535\u052e\u0003',
+  '\u0002\u0002\u0002\u0536\u0539\u0003\u0002\u0002\u0002\u0537\u0535\u0003',
+  '\u0002\u0002\u0002\u0537\u0538\u0003\u0002\u0002\u0002\u0538\u0542\u0003',
+  '\u0002\u0002\u0002\u0539\u0537\u0003\u0002\u0002\u0002\u053a\u053c\u0005',
+  '\u00acW\u0002\u053b\u053d\u0007\u0099\u0002\u0002\u053c\u053b\u0003',
+  '\u0002\u0002\u0002\u053c\u053d\u0003\u0002\u0002\u0002\u053d\u053f\u0003',
+  '\u0002\u0002\u0002\u053e\u0540\u0005\u00b2Z\u0002\u053f\u053e\u0003',
+  '\u0002\u0002\u0002\u053f\u0540\u0003\u0002\u0002\u0002\u0540\u0542\u0003',
+  '\u0002\u0002\u0002\u0541\u051e\u0003\u0002\u0002\u0002\u0541\u052c\u0003',
+  '\u0002\u0002\u0002\u0541\u053a\u0003\u0002\u0002\u0002\u0542\u00a7\u0003',
+  '\u0002\u0002\u0002\u0543\u0544\u0005\u0102\u0082\u0002\u0544\u0545\u0007',
+  '\u0099\u0002\u0002\u0545\u0546\u0007N\u0002\u0002\u0546\u0547\u0007',
+  '\u0099\u0002\u0002\u0547\u0548\u0005\u0166\u00b4\u0002\u0548\u054b\u0003',
+  '\u0002\u0002\u0002\u0549\u054b\u0005\u0102\u0082\u0002\u054a\u0543\u0003',
+  '\u0002\u0002\u0002\u054a\u0549\u0003\u0002\u0002\u0002\u054b\u00a9\u0003',
+  '\u0002\u0002\u0002\u054c\u054d\u0007\u0083\u0002\u0002\u054d\u054e\u0007',
+  '\u0099\u0002\u0002\u054e\u0550\u0005\u00acW\u0002\u054f\u0551\u0007',
+  '\u0099\u0002\u0002\u0550\u054f\u0003\u0002\u0002\u0002\u0550\u0551\u0003',
+  '\u0002\u0002\u0002\u0551\u0553\u0003\u0002\u0002\u0002\u0552\u0554\u0005',
+  '\u00b2Z\u0002\u0553\u0552\u0003\u0002\u0002\u0002\u0553\u0554\u0003',
+  '\u0002\u0002\u0002\u0554\u00ab\u0003\u0002\u0002\u0002\u0555\u0557\u0005',
+  '\u00aeX\u0002\u0556\u0558\u0007\u0099\u0002\u0002\u0557\u0556\u0003',
+  '\u0002\u0002\u0002\u0557\u0558\u0003\u0002\u0002\u0002\u0558\u055a\u0003',
+  '\u0002\u0002\u0002\u0559\u055b\u0005\u00b0Y\u0002\u055a\u0559\u0003',
+  '\u0002\u0002\u0002\u055a\u055b\u0003\u0002\u0002\u0002\u055b\u00ad\u0003',
+  '\u0002\u0002\u0002\u055c\u055d\u0005\u018c\u00c7\u0002\u055d\u055e\u0005',
+  '\u015a\u00ae\u0002\u055e\u00af\u0003\u0002\u0002\u0002\u055f\u0561\u0007',
+  '\u0015\u0002\u0002\u0560\u0562\u0007\u0099\u0002\u0002\u0561\u0560\u0003',
+  '\u0002\u0002\u0002\u0561\u0562\u0003\u0002\u0002\u0002\u0562\u0564\u0003',
+  '\u0002\u0002\u0002\u0563\u0565\u0005\u0102\u0082\u0002\u0564\u0563\u0003',
+  '\u0002\u0002\u0002\u0564\u0565\u0003\u0002\u0002\u0002\u0565\u0570\u0003',
+  '\u0002\u0002\u0002\u0566\u0568\u0007\u0099\u0002\u0002\u0567\u0566\u0003',
+  '\u0002\u0002\u0002\u0567\u0568\u0003\u0002\u0002\u0002\u0568\u0569\u0003',
+  '\u0002\u0002\u0002\u0569\u056b\u0007\u0011\u0002\u0002\u056a\u056c\u0007',
+  '\u0099\u0002\u0002\u056b\u056a\u0003\u0002\u0002\u0002\u056b\u056c\u0003',
+  '\u0002\u0002\u0002\u056c\u056d\u0003\u0002\u0002\u0002\u056d\u056f\u0005',
+  '\u0102\u0082\u0002\u056e\u0567\u0003\u0002\u0002\u0002\u056f\u0572\u0003',
+  '\u0002\u0002\u0002\u0570\u056e\u0003\u0002\u0002\u0002\u0570\u0571\u0003',
+  '\u0002\u0002\u0002\u0571\u0574\u0003\u0002\u0002\u0002\u0572\u0570\u0003',
+  '\u0002\u0002\u0002\u0573\u0575\u0007\u0099\u0002\u0002\u0574\u0573\u0003',
+  '\u0002\u0002\u0002\u0574\u0575\u0003\u0002\u0002\u0002\u0575\u0576\u0003',
+  '\u0002\u0002\u0002\u0576\u0577\u0007\u0016\u0002\u0002\u0577\u00b1\u0003',
+  '\u0002\u0002\u0002\u0578\u0579\u0007\u0084\u0002\u0002\u0579\u057a\u0007',
+  '\u0099\u0002\u0002\u057a\u0585\u0005\u00b4[\u0002\u057b\u057d\u0007',
+  '\u0099\u0002\u0002\u057c\u057b\u0003\u0002\u0002\u0002\u057c\u057d\u0003',
+  '\u0002\u0002\u0002\u057d\u057e\u0003\u0002\u0002\u0002\u057e\u0580\u0007',
+  '\u0011\u0002\u0002\u057f\u0581\u0007\u0099\u0002\u0002\u0580\u057f\u0003',
+  '\u0002\u0002\u0002\u0580\u0581\u0003\u0002\u0002\u0002\u0581\u0582\u0003',
+  '\u0002\u0002\u0002\u0582\u0584\u0005\u00b4[\u0002\u0583\u057c\u0003',
+  '\u0002\u0002\u0002\u0584\u0587\u0003\u0002\u0002\u0002\u0585\u0583\u0003',
+  '\u0002\u0002\u0002\u0585\u0586\u0003\u0002\u0002\u0002\u0586\u058a\u0003',
+  '\u0002\u0002\u0002\u0587\u0585\u0003\u0002\u0002\u0002\u0588\u0589\u0007',
+  '\u0099\u0002\u0002\u0589\u058b\u0005\u00d8m\u0002\u058a\u0588\u0003',
+  '\u0002\u0002\u0002\u058a\u058b\u0003\u0002\u0002\u0002\u058b\u00b3\u0003',
+  '\u0002\u0002\u0002\u058c\u058f\u0005\u00b6\\\u0002\u058d\u058f\u0005',
+  '\u00b8]\u0002\u058e\u058c\u0003\u0002\u0002\u0002\u058e\u058d\u0003',
+  '\u0002\u0002\u0002\u058f\u00b5\u0003\u0002\u0002\u0002\u0590\u0591\u0005',
+  '\u00ba^\u0002\u0591\u0592\u0007\u0099\u0002\u0002\u0592\u0593\u0007',
+  'N\u0002\u0002\u0593\u0594\u0007\u0099\u0002\u0002\u0594\u0595\u0005',
+  '\u0166\u00b4\u0002\u0595\u00b7\u0003\u0002\u0002\u0002\u0596\u0597\u0005',
+  '\u00ba^\u0002\u0597\u00b9\u0003\u0002\u0002\u0002\u0598\u0599\u0005',
+  '\u0194\u00cb\u0002\u0599\u00bb\u0003\u0002\u0002\u0002\u059a\u059b\u0007',
+  '\\\u0002\u0002\u059b\u059c\u0007\u0099\u0002\u0002\u059c\u059d\u0007',
+  ']\u0002\u0002\u059d\u059e\u0007\u0099\u0002\u0002\u059e\u05a9\u0005',
+  '\u00c2b\u0002\u059f\u05a1\u0007\u0099\u0002\u0002\u05a0\u059f\u0003',
+  '\u0002\u0002\u0002\u05a0\u05a1\u0003\u0002\u0002\u0002\u05a1\u05a2\u0003',
+  '\u0002\u0002\u0002\u05a2\u05a4\u0007\u0011\u0002\u0002\u05a3\u05a5\u0007',
+  '\u0099\u0002\u0002\u05a4\u05a3\u0003\u0002\u0002\u0002\u05a4\u05a5\u0003',
+  '\u0002\u0002\u0002\u05a5\u05a6\u0003\u0002\u0002\u0002\u05a6\u05a8\u0005',
+  '\u00c2b\u0002\u05a7\u05a0\u0003\u0002\u0002\u0002\u05a8\u05ab\u0003',
+  '\u0002\u0002\u0002\u05a9\u05a7\u0003\u0002\u0002\u0002\u05a9\u05aa\u0003',
+  '\u0002\u0002\u0002\u05aa\u00bd\u0003\u0002\u0002\u0002\u05ab\u05a9\u0003',
+  '\u0002\u0002\u0002\u05ac\u05ad\u0007^\u0002\u0002\u05ad\u05ae\u0007',
+  '\u0099\u0002\u0002\u05ae\u05af\u0005\u0102\u0082\u0002\u05af\u00bf\u0003',
+  '\u0002\u0002\u0002\u05b0\u05b1\u0007_\u0002\u0002\u05b1\u05b2\u0007',
+  '\u0099\u0002\u0002\u05b2\u05b3\u0005\u0102\u0082\u0002\u05b3\u00c1\u0003',
+  '\u0002\u0002\u0002\u05b4\u05bc\u0005\u0102\u0082\u0002\u05b5\u05b7\u0007',
+  '\u0099\u0002\u0002\u05b6\u05b5\u0003\u0002\u0002\u0002\u05b6\u05b7\u0003',
+  '\u0002\u0002\u0002\u05b7\u05b8\u0003\u0002\u0002\u0002\u05b8\u05ba\t',
+  '\u0003\u0002\u0002\u05b9\u05bb\u0007\u0099\u0002\u0002\u05ba\u05b9\u0003',
+  '\u0002\u0002\u0002\u05ba\u05bb\u0003\u0002\u0002\u0002\u05bb\u05bd\u0003',
+  '\u0002\u0002\u0002\u05bc\u05b6\u0003\u0002\u0002\u0002\u05bc\u05bd\u0003',
+  '\u0002\u0002\u0002\u05bd\u00c3\u0003\u0002\u0002\u0002\u05be\u05c0\u0007',
+  '\u0099\u0002\u0002\u05bf\u05be\u0003\u0002\u0002\u0002\u05bf\u05c0\u0003',
+  '\u0002\u0002\u0002\u05c0\u05ef\u0003\u0002\u0002\u0002\u05c1\u05c2\u0007',
+  ';\u0002\u0002\u05c2\u05c3\u0007\u0099\u0002\u0002\u05c3\u05c4\u0007',
+  'B\u0002\u0002\u05c4\u05c5\u0007\u0099\u0002\u0002\u05c5\u05c6\u0005',
+  '\u0166\u00b4\u0002\u05c6\u05c8\u0005\u00fa~\u0002\u05c7\u05c9\u0007',
+  '\u0099\u0002\u0002\u05c8\u05c7\u0003\u0002\u0002\u0002\u05c8\u05c9\u0003',
+  '\u0002\u0002\u0002\u05c9\u05ca\u0003\u0002\u0002\u0002\u05ca\u05cc\u0007',
+  '\u0015\u0002\u0002\u05cb\u05cd\u0007\u0099\u0002\u0002\u05cc\u05cb\u0003',
+  '\u0002\u0002\u0002\u05cc\u05cd\u0003\u0002\u0002\u0002\u05cd\u05ce\u0003',
+  '\u0002\u0002\u0002\u05ce\u05d0\u0005\u0184\u00c3\u0002\u05cf\u05d1\u0007',
+  '\u0099\u0002\u0002\u05d0\u05cf\u0003\u0002\u0002\u0002\u05d0\u05d1\u0003',
+  '\u0002\u0002\u0002\u05d1\u05d2\u0003\u0002\u0002\u0002\u05d2\u05d3\u0007',
+  '\u0016\u0002\u0002\u05d3\u05f0\u0003\u0002\u0002\u0002\u05d4\u05d5\u0007',
+  ';\u0002\u0002\u05d5\u05d6\u0007\u0099\u0002\u0002\u05d6\u05d7\u0007',
+  'd\u0002\u0002\u05d7\u05d8\u0007\u0099\u0002\u0002\u05d8\u05d9\u0007',
+  'C\u0002\u0002\u05d9\u05da\u0007\u0099\u0002\u0002\u05da\u05e5\u0005',
+  '\u0166\u00b4\u0002\u05db\u05dd\u0007\u0099\u0002\u0002\u05dc\u05db\u0003',
+  '\u0002\u0002\u0002\u05dc\u05dd\u0003\u0002\u0002\u0002\u05dd\u05de\u0003',
+  '\u0002\u0002\u0002\u05de\u05e0\u0007\u0011\u0002\u0002\u05df\u05e1\u0007',
+  '\u0099\u0002\u0002\u05e0\u05df\u0003\u0002\u0002\u0002\u05e0\u05e1\u0003',
+  '\u0002\u0002\u0002\u05e1\u05e2\u0003\u0002\u0002\u0002\u05e2\u05e4\u0005',
+  '\u0166\u00b4\u0002\u05e3\u05dc\u0003\u0002\u0002\u0002\u05e4\u05e7\u0003',
+  '\u0002\u0002\u0002\u05e5\u05e3\u0003\u0002\u0002\u0002\u05e5\u05e6\u0003',
+  '\u0002\u0002\u0002\u05e6\u05f0\u0003\u0002\u0002\u0002\u05e7\u05e5\u0003',
+  '\u0002\u0002\u0002\u05e8\u05e9\u0007;\u0002\u0002\u05e9\u05ea\u0007',
+  '\u0099\u0002\u0002\u05ea\u05eb\u0007e\u0002\u0002\u05eb\u05ec\u0007',
+  '\u0099\u0002\u0002\u05ec\u05ed\u0005\u0166\u00b4\u0002\u05ed\u05ee\u0005',
+  '\u00fa~\u0002\u05ee\u05f0\u0003\u0002\u0002\u0002\u05ef\u05c1\u0003',
+  '\u0002\u0002\u0002\u05ef\u05d4\u0003\u0002\u0002\u0002\u05ef\u05e8\u0003',
+  '\u0002\u0002\u0002\u05f0\u00c5\u0003\u0002\u0002\u0002\u05f1\u05f2\u0007',
+  'f\u0002\u0002\u05f2\u05f3\u0007\u0099\u0002\u0002\u05f3\u05fe\u0005',
+  '\u00c8e\u0002\u05f4\u05f6\u0007\u0099\u0002\u0002\u05f5\u05f4\u0003',
+  '\u0002\u0002\u0002\u05f5\u05f6\u0003\u0002\u0002\u0002\u05f6\u05f7\u0003',
+  '\u0002\u0002\u0002\u05f7\u05f9\u0007\u0011\u0002\u0002\u05f8\u05fa\u0007',
+  '\u0099\u0002\u0002\u05f9\u05f8\u0003\u0002\u0002\u0002\u05f9\u05fa\u0003',
+  '\u0002\u0002\u0002\u05fa\u05fb\u0003\u0002\u0002\u0002\u05fb\u05fd\u0005',
+  '\u00c8e\u0002\u05fc\u05f5\u0003\u0002\u0002\u0002\u05fd\u0600\u0003',
+  '\u0002\u0002\u0002\u05fe\u05fc\u0003\u0002\u0002\u0002\u05fe\u05ff\u0003',
+  '\u0002\u0002\u0002\u05ff\u0602\u0003\u0002\u0002\u0002\u0600\u05fe\u0003',
+  '\u0002\u0002\u0002\u0601\u0603\u0005\u00d8m\u0002\u0602\u0601\u0003',
+  '\u0002\u0002\u0002\u0602\u0603\u0003\u0002\u0002\u0002\u0603\u00c7\u0003',
+  '\u0002\u0002\u0002\u0604\u0606\u0005\u0166\u00b4\u0002\u0605\u0607\u0007',
+  '\u0099\u0002\u0002\u0606\u0605\u0003\u0002\u0002\u0002\u0606\u0607\u0003',
+  '\u0002\u0002\u0002\u0607\u0608\u0003\u0002\u0002\u0002\u0608\u060a\u0007',
+  '\u000e\u0002\u0002\u0609\u060b\u0007\u0099\u0002\u0002\u060a\u0609\u0003',
+  '\u0002\u0002\u0002\u060a\u060b\u0003\u0002\u0002\u0002\u060b\u060c\u0003',
+  '\u0002\u0002\u0002\u060c\u060d\u0005\u00caf\u0002\u060d\u00c9\u0003',
+  '\u0002\u0002\u0002\u060e\u0611\u0005\u00ccg\u0002\u060f\u0611\u0005',
+  '\u00ceh\u0002\u0610\u060e\u0003\u0002\u0002\u0002\u0610\u060f\u0003',
+  '\u0002\u0002\u0002\u0611\u00cb\u0003\u0002\u0002\u0002\u0612\u0614\u0007',
+  'g\u0002\u0002\u0613\u0615\u0007\u0099\u0002\u0002\u0614\u0613\u0003',
+  '\u0002\u0002\u0002\u0614\u0615\u0003\u0002\u0002\u0002\u0615\u0619\u0003',
+  '\u0002\u0002\u0002\u0616\u061a\u0005\u00d0i\u0002\u0617\u061a\u0005',
+  '\u00d2j\u0002\u0618\u061a\u0005\u00d4k\u0002\u0619\u0616\u0003\u0002',
+  '\u0002\u0002\u0619\u0617\u0003\u0002\u0002\u0002\u0619\u0618\u0003\u0002',
+  '\u0002\u0002\u061a\u00cd\u0003\u0002\u0002\u0002\u061b\u061f\t\u0004',
+  '\u0002\u0002\u061c\u0620\u0005\u00d0i\u0002\u061d\u0620\u0005\u00d2',
+  'j\u0002\u061e\u0620\u0005\u00d4k\u0002\u061f\u061c\u0003\u0002\u0002',
+  '\u0002\u061f\u061d\u0003\u0002\u0002\u0002\u061f\u061e\u0003\u0002\u0002',
+  '\u0002\u0620\u00cf\u0003\u0002\u0002\u0002\u0621\u0622\u0007\u0004\u0002',
+  '\u0002\u0622\u0623\u0005\u0194\u00cb\u0002\u0623\u0624\u0007\u0015\u0002',
+  '\u0002\u0624\u0625\u0005\u0194\u00cb\u0002\u0625\u0628\u0007\u000e\u0002',
+  '\u0002\u0626\u0629\u0007\u0086\u0002\u0002\u0627\u0629\u0005\u0178\u00bd',
+  '\u0002\u0628\u0626\u0003\u0002\u0002\u0002\u0628\u0627\u0003\u0002\u0002',
+  '\u0002\u0629\u062a\u0003\u0002\u0002\u0002\u062a\u062b\u0007\u0016\u0002',
+  '\u0002\u062b\u00d1\u0003\u0002\u0002\u0002\u062c\u062d\u0007\u0004\u0002',
+  '\u0002\u062d\u062e\u0005\u0194\u00cb\u0002\u062e\u0631\u0007\u0015\u0002',
+  '\u0002\u062f\u0632\u0007\u0086\u0002\u0002\u0630\u0632\u0005\u0178\u00bd',
+  '\u0002\u0631\u062f\u0003\u0002\u0002\u0002\u0631\u0630\u0003\u0002\u0002',
+  '\u0002\u0632\u0633\u0003\u0002\u0002\u0002\u0633\u0634\u0007\u0016\u0002',
+  '\u0002\u0634\u00d3\u0003\u0002\u0002\u0002\u0635\u0639\u0007\u0015\u0002',
+  '\u0002\u0636\u063a\u0005\u00d6l\u0002\u0637\u063a\u0005\u0178\u00bd',
+  '\u0002\u0638\u063a\u0007\u0019\u0002\u0002\u0639\u0636\u0003\u0002\u0002',
+  '\u0002\u0639\u0637\u0003\u0002\u0002\u0002\u0639\u0638\u0003\u0002\u0002',
+  '\u0002\u063a\u063b\u0003\u0002\u0002\u0002\u063b\u063c\u0007\u0016\u0002',
+  '\u0002\u063c\u00d5\u0003\u0002\u0002\u0002\u063d\u0648\u0005\u0188\u00c5',
+  '\u0002\u063e\u0640\u0007\u0099\u0002\u0002\u063f\u063e\u0003\u0002\u0002',
+  '\u0002\u063f\u0640\u0003\u0002\u0002\u0002\u0640\u0641\u0003\u0002\u0002',
+  '\u0002\u0641\u0643\u0007\u0011\u0002\u0002\u0642\u0644\u0007\u0099\u0002',
+  '\u0002\u0643\u0642\u0003\u0002\u0002\u0002\u0643\u0644\u0003\u0002\u0002',
+  '\u0002\u0644\u0645\u0003\u0002\u0002\u0002\u0645\u0647\u0005\u0188\u00c5',
+  '\u0002\u0646\u063f\u0003\u0002\u0002\u0002\u0647\u064a\u0003\u0002\u0002',
+  '\u0002\u0648\u0646\u0003\u0002\u0002\u0002\u0648\u0649\u0003\u0002\u0002',
+  '\u0002\u0649\u00d7\u0003\u0002\u0002\u0002\u064a\u0648\u0003\u0002\u0002',
+  '\u0002\u064b\u064c\u0007j\u0002\u0002\u064c\u064d\u0007\u0099\u0002',
+  '\u0002\u064d\u064e\u0005\u0102\u0082\u0002\u064e\u00d9\u0003\u0002\u0002',
+  '\u0002\u064f\u065a\u0005\u00dco\u0002\u0650\u0652\u0007\u0099\u0002',
+  '\u0002\u0651\u0650\u0003\u0002\u0002\u0002\u0651\u0652\u0003\u0002\u0002',
+  '\u0002\u0652\u0653\u0003\u0002\u0002\u0002\u0653\u0655\u0007\u0011\u0002',
+  '\u0002\u0654\u0656\u0007\u0099\u0002\u0002\u0655\u0654\u0003\u0002\u0002',
+  '\u0002\u0655\u0656\u0003\u0002\u0002\u0002\u0656\u0657\u0003\u0002\u0002',
+  '\u0002\u0657\u0659\u0005\u00dco\u0002\u0658\u0651\u0003\u0002\u0002',
+  '\u0002\u0659\u065c\u0003\u0002\u0002\u0002\u065a\u0658\u0003\u0002\u0002',
+  '\u0002\u065a\u065b\u0003\u0002\u0002\u0002\u065b\u00db\u0003\u0002\u0002',
+  '\u0002\u065c\u065a\u0003\u0002\u0002\u0002\u065d\u065f\u0005\u0166\u00b4',
+  '\u0002\u065e\u0660\u0007\u0099\u0002\u0002\u065f\u065e\u0003\u0002\u0002',
+  '\u0002\u065f\u0660\u0003\u0002\u0002\u0002\u0660\u0661\u0003\u0002\u0002',
+  '\u0002\u0661\u0663\u0007\u000e\u0002\u0002\u0662\u0664\u0007\u0099\u0002',
+  '\u0002\u0663\u0662\u0003\u0002\u0002\u0002\u0663\u0664\u0003\u0002\u0002',
+  '\u0002\u0664\u0665\u0003\u0002\u0002\u0002\u0665\u0666\u0005\u00dep',
+  '\u0002\u0666\u0669\u0003\u0002\u0002\u0002\u0667\u0669\u0005\u00dep',
+  '\u0002\u0668\u065d\u0003\u0002\u0002\u0002\u0668\u0667\u0003\u0002\u0002',
+  '\u0002\u0669\u00dd\u0003\u0002\u0002\u0002\u066a\u066d\u0005\u013a\u009e',
+  '\u0002\u066b\u066d\u0005\u00e0q\u0002\u066c\u066a\u0003\u0002\u0002',
+  '\u0002\u066c\u066b\u0003\u0002\u0002\u0002\u066d\u00df\u0003\u0002\u0002',
+  '\u0002\u066e\u0675\u0005\u00e2r\u0002\u066f\u0671\u0007\u0099\u0002',
+  '\u0002\u0670\u066f\u0003\u0002\u0002\u0002\u0670\u0671\u0003\u0002\u0002',
+  '\u0002\u0671\u0672\u0003\u0002\u0002\u0002\u0672\u0674\u0005\u00e4s',
+  '\u0002\u0673\u0670\u0003\u0002\u0002\u0002\u0674\u0677\u0003\u0002\u0002',
+  '\u0002\u0675\u0673\u0003\u0002\u0002\u0002\u0675\u0676\u0003\u0002\u0002',
+  '\u0002\u0676\u067d\u0003\u0002\u0002\u0002\u0677\u0675\u0003\u0002\u0002',
+  '\u0002\u0678\u0679\u0007\u0015\u0002\u0002\u0679\u067a\u0005\u00e0q',
+  '\u0002\u067a\u067b\u0007\u0016\u0002\u0002\u067b\u067d\u0003\u0002\u0002',
+  '\u0002\u067c\u066e\u0003\u0002\u0002\u0002\u067c\u0678\u0003\u0002\u0002',
+  '\u0002\u067d\u00e1\u0003\u0002\u0002\u0002\u067e\u0680\u0007\u0015\u0002',
+  '\u0002\u067f\u0681\u0007\u0099\u0002\u0002\u0680\u067f\u0003\u0002\u0002',
+  '\u0002\u0680\u0681\u0003\u0002\u0002\u0002\u0681\u0686\u0003\u0002\u0002',
+  '\u0002\u0682\u0684\u0005\u0166\u00b4\u0002\u0683\u0685\u0007\u0099\u0002',
+  '\u0002\u0684\u0683\u0003\u0002\u0002\u0002\u0684\u0685\u0003\u0002\u0002',
+  '\u0002\u0685\u0687\u0003\u0002\u0002\u0002\u0686\u0682\u0003\u0002\u0002',
+  '\u0002\u0686\u0687\u0003\u0002\u0002\u0002\u0687\u068c\u0003\u0002\u0002',
+  '\u0002\u0688\u068a\u0005\u00f8}\u0002\u0689\u068b\u0007\u0099\u0002',
+  '\u0002\u068a\u0689\u0003\u0002\u0002\u0002\u068a\u068b\u0003\u0002\u0002',
+  '\u0002\u068b\u068d\u0003\u0002\u0002\u0002\u068c\u0688\u0003\u0002\u0002',
+  '\u0002\u068c\u068d\u0003\u0002\u0002\u0002\u068d\u0692\u0003\u0002\u0002',
+  '\u0002\u068e\u0690\u0005\u00eex\u0002\u068f\u0691\u0007\u0099\u0002',
+  '\u0002\u0690\u068f\u0003\u0002\u0002\u0002\u0690\u0691\u0003\u0002\u0002',
+  '\u0002\u0691\u0693\u0003\u0002\u0002\u0002\u0692\u068e\u0003\u0002\u0002',
+  '\u0002\u0692\u0693\u0003\u0002\u0002\u0002\u0693\u0694\u0003\u0002\u0002',
+  '\u0002\u0694\u0695\u0007\u0016\u0002\u0002\u0695\u00e3\u0003\u0002\u0002',
+  '\u0002\u0696\u0698\u0005\u00e6t\u0002\u0697\u0699\u0007\u0099\u0002',
+  '\u0002\u0698\u0697\u0003\u0002\u0002\u0002\u0698\u0699\u0003\u0002\u0002',
+  '\u0002\u0699\u069a\u0003\u0002\u0002\u0002\u069a\u069b\u0005\u00e2r',
+  '\u0002\u069b\u00e5\u0003\u0002\u0002\u0002\u069c\u069e\u0005\u00e8u',
+  '\u0002\u069d\u069f\u0007\u0099\u0002\u0002\u069e\u069d\u0003\u0002\u0002',
+  '\u0002\u069e\u069f\u0003\u0002\u0002\u0002\u069f\u06a1\u0003\u0002\u0002',
+  '\u0002\u06a0\u06a2\u0005\u00ecw\u0002\u06a1\u06a0\u0003\u0002\u0002',
+  '\u0002\u06a1\u06a2\u0003\u0002\u0002\u0002\u06a2\u06a4\u0003\u0002\u0002',
+  '\u0002\u06a3\u06a5\u0007\u0099\u0002\u0002\u06a4\u06a3\u0003\u0002\u0002',
+  '\u0002\u06a4\u06a5\u0003\u0002\u0002\u0002\u06a5\u06a6\u0003\u0002\u0002',
+  '\u0002\u06a6\u06a7\u0005\u00eav\u0002\u06a7\u00e7\u0003\u0002\u0002',
+  '\u0002\u06a8\u06aa\u0005\u018e\u00c8\u0002\u06a9\u06ab\u0007\u0099\u0002',
+  '\u0002\u06aa\u06a9\u0003\u0002\u0002\u0002\u06aa\u06ab\u0003\u0002\u0002',
+  '\u0002\u06ab\u06ac\u0003\u0002\u0002\u0002\u06ac\u06ad\u0005\u0192\u00ca',
+  '\u0002\u06ad\u06b0\u0003\u0002\u0002\u0002\u06ae\u06b0\u0005\u0192\u00ca',
+  '\u0002\u06af\u06a8\u0003\u0002\u0002\u0002\u06af\u06ae\u0003\u0002\u0002',
+  '\u0002\u06b0\u00e9\u0003\u0002\u0002\u0002\u06b1\u06b3\u0005\u0192\u00ca',
+  '\u0002\u06b2\u06b4\u0007\u0099\u0002\u0002\u06b3\u06b2\u0003\u0002\u0002',
+  '\u0002\u06b3\u06b4\u0003\u0002\u0002\u0002\u06b4\u06b5\u0003\u0002\u0002',
+  '\u0002\u06b5\u06b6\u0005\u0190\u00c9\u0002\u06b6\u06b9\u0003\u0002\u0002',
+  '\u0002\u06b7\u06b9\u0005\u0192\u00ca\u0002\u06b8\u06b1\u0003\u0002\u0002',
+  '\u0002\u06b8\u06b7\u0003\u0002\u0002\u0002\u06b9\u00eb\u0003\u0002\u0002',
+  '\u0002\u06ba\u06bc\u0007\u0013\u0002\u0002\u06bb\u06bd\u0007\u0099\u0002',
+  '\u0002\u06bc\u06bb\u0003\u0002\u0002\u0002\u06bc\u06bd\u0003\u0002\u0002',
+  '\u0002\u06bd\u06c2\u0003\u0002\u0002\u0002\u06be\u06c0\u0005\u0166\u00b4',
+  '\u0002\u06bf\u06c1\u0007\u0099\u0002\u0002\u06c0\u06bf\u0003\u0002\u0002',
+  '\u0002\u06c0\u06c1\u0003\u0002\u0002\u0002\u06c1\u06c3\u0003\u0002\u0002',
+  '\u0002\u06c2\u06be\u0003\u0002\u0002\u0002\u06c2\u06c3\u0003\u0002\u0002',
+  '\u0002\u06c3\u06c8\u0003\u0002\u0002\u0002\u06c4\u06c6\u0005\u00f2z',
+  '\u0002\u06c5\u06c7\u0007\u0099\u0002\u0002\u06c6\u06c5\u0003\u0002\u0002',
+  '\u0002\u06c6\u06c7\u0003\u0002\u0002\u0002\u06c7\u06c9\u0003\u0002\u0002',
+  '\u0002\u06c8\u06c4\u0003\u0002\u0002\u0002\u06c8\u06c9\u0003\u0002\u0002',
+  '\u0002\u06c9\u06cb\u0003\u0002\u0002\u0002\u06ca\u06cc\u0005\u00fc\u007f',
+  '\u0002\u06cb\u06ca\u0003\u0002\u0002\u0002\u06cb\u06cc\u0003\u0002\u0002',
+  '\u0002\u06cc\u06d1\u0003\u0002\u0002\u0002\u06cd\u06cf\u0005\u00eex',
+  '\u0002\u06ce\u06d0\u0007\u0099\u0002\u0002\u06cf\u06ce\u0003\u0002\u0002',
+  '\u0002\u06cf\u06d0\u0003\u0002\u0002\u0002\u06d0\u06d2\u0003\u0002\u0002',
+  '\u0002\u06d1\u06cd\u0003\u0002\u0002\u0002\u06d1\u06d2\u0003\u0002\u0002',
+  '\u0002\u06d2\u06d3\u0003\u0002\u0002\u0002\u06d3\u06d4\u0007\u0014\u0002',
+  '\u0002\u06d4\u00ed\u0003\u0002\u0002\u0002\u06d5\u06d8\u0005\u016a\u00b6',
+  '\u0002\u06d6\u06d8\u0005\u0178\u00bd\u0002\u06d7\u06d5\u0003\u0002\u0002',
+  '\u0002\u06d7\u06d6\u0003\u0002\u0002\u0002\u06d8\u00ef\u0003\u0002\u0002',
+  '\u0002\u06d9\u06db\u0007\u0004\u0002\u0002\u06da\u06dc\u0007\u0099\u0002',
+  '\u0002\u06db\u06da\u0003\u0002\u0002\u0002\u06db\u06dc\u0003\u0002\u0002',
+  '\u0002\u06dc\u06dd\u0003\u0002\u0002\u0002\u06dd\u06de\u0005\u0100\u0081',
+  '\u0002\u06de\u00f1\u0003\u0002\u0002\u0002\u06df\u06e7\u0005\u00f4{',
+  '\u0002\u06e0\u06e2\u0007\u0099\u0002\u0002\u06e1\u06e0\u0003\u0002\u0002',
+  '\u0002\u06e1\u06e2\u0003\u0002\u0002\u0002\u06e2\u06e3\u0003\u0002\u0002',
+  '\u0002\u06e3\u06e4\u0007\u0018\u0002\u0002\u06e4\u06e6\u0005\u00f6|',
+  '\u0002\u06e5\u06e1\u0003\u0002\u0002\u0002\u06e6\u06e9\u0003\u0002\u0002',
+  '\u0002\u06e7\u06e5\u0003\u0002\u0002\u0002\u06e7\u06e8\u0003\u0002\u0002',
+  '\u0002\u06e8\u00f3\u0003\u0002\u0002\u0002\u06e9\u06e7\u0003\u0002\u0002',
+  '\u0002\u06ea\u06eb\u0007\u0004\u0002\u0002\u06eb\u06ec\u0005\u0100\u0081',
+  '\u0002\u06ec\u00f5\u0003\u0002\u0002\u0002\u06ed\u06ef\u0007\u0004\u0002',
+  '\u0002\u06ee\u06ed\u0003\u0002\u0002\u0002\u06ee\u06ef\u0003\u0002\u0002',
+  '\u0002\u06ef\u06f0\u0003\u0002\u0002\u0002\u06f0\u06f1\u0005\u0100\u0081',
+  '\u0002\u06f1\u00f7\u0003\u0002\u0002\u0002\u06f2\u06f9\u0005\u00fa~',
+  '\u0002\u06f3\u06f5\u0007\u0099\u0002\u0002\u06f4\u06f3\u0003\u0002\u0002',
+  '\u0002\u06f4\u06f5\u0003\u0002\u0002\u0002\u06f5\u06f6\u0003\u0002\u0002',
+  '\u0002\u06f6\u06f8\u0005\u00fa~\u0002\u06f7\u06f4\u0003\u0002\u0002',
+  '\u0002\u06f8\u06fb\u0003\u0002\u0002\u0002\u06f9\u06f7\u0003\u0002\u0002',
+  '\u0002\u06f9\u06fa\u0003\u0002\u0002\u0002\u06fa\u00f9\u0003\u0002\u0002',
+  '\u0002\u06fb\u06f9\u0003\u0002\u0002\u0002\u06fc\u06fd\u0007\u0004\u0002',
+  '\u0002\u06fd\u06fe\u0005\u00fe\u0080\u0002\u06fe\u00fb\u0003\u0002\u0002',
+  '\u0002\u06ff\u0701\u0007\u0019\u0002\u0002\u0700\u0702\u0007\u0099\u0002',
+  '\u0002\u0701\u0700\u0003\u0002\u0002\u0002\u0701\u0702\u0003\u0002\u0002',
+  '\u0002\u0702\u0707\u0003\u0002\u0002\u0002\u0703\u0705\u0005\u0188\u00c5',
+  '\u0002\u0704\u0706\u0007\u0099\u0002\u0002\u0705\u0704\u0003\u0002\u0002',
+  '\u0002\u0705\u0706\u0003\u0002\u0002\u0002\u0706\u0708\u0003\u0002\u0002',
+  '\u0002\u0707\u0703\u0003\u0002\u0002\u0002\u0707\u0708\u0003\u0002\u0002',
+  '\u0002\u0708\u0713\u0003\u0002\u0002\u0002\u0709\u070b\u0007\u001a\u0002',
+  '\u0002\u070a\u070c\u0007\u0099\u0002\u0002\u070b\u070a\u0003\u0002\u0002',
+  '\u0002\u070b\u070c\u0003\u0002\u0002\u0002\u070c\u0711\u0003\u0002\u0002',
+  '\u0002\u070d\u070f\u0005\u0188\u00c5\u0002\u070e\u0710\u0007\u0099\u0002',
+  '\u0002\u070f\u070e\u0003\u0002\u0002\u0002\u070f\u0710\u0003\u0002\u0002',
+  '\u0002\u0710\u0712\u0003\u0002\u0002\u0002\u0711\u070d\u0003\u0002\u0002',
+  '\u0002\u0711\u0712\u0003\u0002\u0002\u0002\u0712\u0714\u0003\u0002\u0002',
+  '\u0002\u0713\u0709\u0003\u0002\u0002\u0002\u0713\u0714\u0003\u0002\u0002',
+  '\u0002\u0714\u00fd\u0003\u0002\u0002\u0002\u0715\u0716\u0005\u0194\u00cb',
+  '\u0002\u0716\u00ff\u0003\u0002\u0002\u0002\u0717\u0718\u0005\u0194\u00cb',
+  '\u0002\u0718\u0101\u0003\u0002\u0002\u0002\u0719\u071a\u0005\u0104\u0083',
+  '\u0002\u071a\u0103\u0003\u0002\u0002\u0002\u071b\u0722\u0005\u0106\u0084',
+  '\u0002\u071c\u071d\u0007\u0099\u0002\u0002\u071d\u071e\u0007m\u0002',
+  '\u0002\u071e\u071f\u0007\u0099\u0002\u0002\u071f\u0721\u0005\u0106\u0084',
+  '\u0002\u0720\u071c\u0003\u0002\u0002\u0002\u0721\u0724\u0003\u0002\u0002',
+  '\u0002\u0722\u0720\u0003\u0002\u0002\u0002\u0722\u0723\u0003\u0002\u0002',
+  '\u0002\u0723\u0105\u0003\u0002\u0002\u0002\u0724\u0722\u0003\u0002\u0002',
+  '\u0002\u0725\u072c\u0005\u0108\u0085\u0002\u0726\u0727\u0007\u0099\u0002',
+  '\u0002\u0727\u0728\u0007n\u0002\u0002\u0728\u0729\u0007\u0099\u0002',
+  '\u0002\u0729\u072b\u0005\u0108\u0085\u0002\u072a\u0726\u0003\u0002\u0002',
+  '\u0002\u072b\u072e\u0003\u0002\u0002\u0002\u072c\u072a\u0003\u0002\u0002',
+  '\u0002\u072c\u072d\u0003\u0002\u0002\u0002\u072d\u0107\u0003\u0002\u0002',
+  '\u0002\u072e\u072c\u0003\u0002\u0002\u0002\u072f\u0736\u0005\u010a\u0086',
+  '\u0002\u0730\u0731\u0007\u0099\u0002\u0002\u0731\u0732\u0007o\u0002',
+  '\u0002\u0732\u0733\u0007\u0099\u0002\u0002\u0733\u0735\u0005\u010a\u0086',
+  '\u0002\u0734\u0730\u0003\u0002\u0002\u0002\u0735\u0738\u0003\u0002\u0002',
+  '\u0002\u0736\u0734\u0003\u0002\u0002\u0002\u0736\u0737\u0003\u0002\u0002',
+  '\u0002\u0737\u0109\u0003\u0002\u0002\u0002\u0738\u0736\u0003\u0002\u0002',
+  '\u0002\u0739\u073b\u0007p\u0002\u0002\u073a\u073c\u0007\u0099\u0002',
+  '\u0002\u073b\u073a\u0003\u0002\u0002\u0002\u073b\u073c\u0003\u0002\u0002',
+  '\u0002\u073c\u073e\u0003\u0002\u0002\u0002\u073d\u0739\u0003\u0002\u0002',
+  '\u0002\u073e\u0741\u0003\u0002\u0002\u0002\u073f\u073d\u0003\u0002\u0002',
+  '\u0002\u073f\u0740\u0003\u0002\u0002\u0002\u0740\u0742\u0003\u0002\u0002',
+  '\u0002\u0741\u073f\u0003\u0002\u0002\u0002\u0742\u0743\u0005\u010c\u0087',
+  '\u0002\u0743\u010b\u0003\u0002\u0002\u0002\u0744\u074b\u0005\u010e\u0088',
+  '\u0002\u0745\u0747\u0007\u0099\u0002\u0002\u0746\u0745\u0003\u0002\u0002',
+  '\u0002\u0746\u0747\u0003\u0002\u0002\u0002\u0747\u0748\u0003\u0002\u0002',
+  '\u0002\u0748\u074a\u0005\u014a\u00a6\u0002\u0749\u0746\u0003\u0002\u0002',
+  '\u0002\u074a\u074d\u0003\u0002\u0002\u0002\u074b\u0749\u0003\u0002\u0002',
+  '\u0002\u074b\u074c\u0003\u0002\u0002\u0002\u074c\u010d\u0003\u0002\u0002',
+  '\u0002\u074d\u074b\u0003\u0002\u0002\u0002\u074e\u0761\u0005\u0110\u0089',
+  '\u0002\u074f\u0751\u0007\u0099\u0002\u0002\u0750\u074f\u0003\u0002\u0002',
+  '\u0002\u0750\u0751\u0003\u0002\u0002\u0002\u0751\u0752\u0003\u0002\u0002',
+  '\u0002\u0752\u0754\u0007\u000f\u0002\u0002\u0753\u0755\u0007\u0099\u0002',
+  '\u0002\u0754\u0753\u0003\u0002\u0002\u0002\u0754\u0755\u0003\u0002\u0002',
+  '\u0002\u0755\u0756\u0003\u0002\u0002\u0002\u0756\u0760\u0005\u0110\u0089',
+  '\u0002\u0757\u0759\u0007\u0099\u0002\u0002\u0758\u0757\u0003\u0002\u0002',
+  '\u0002\u0758\u0759\u0003\u0002\u0002\u0002\u0759\u075a\u0003\u0002\u0002',
+  '\u0002\u075a\u075c\u0007\u0005\u0002\u0002\u075b\u075d\u0007\u0099\u0002',
+  '\u0002\u075c\u075b\u0003\u0002\u0002\u0002\u075c\u075d\u0003\u0002\u0002',
+  '\u0002\u075d\u075e\u0003\u0002\u0002\u0002\u075e\u0760\u0005\u0110\u0089',
+  '\u0002\u075f\u0750\u0003\u0002\u0002\u0002\u075f\u0758\u0003\u0002\u0002',
+  '\u0002\u0760\u0763\u0003\u0002\u0002\u0002\u0761\u075f\u0003\u0002\u0002',
+  '\u0002\u0761\u0762\u0003\u0002\u0002\u0002\u0762\u010f\u0003\u0002\u0002',
+  '\u0002\u0763\u0761\u0003\u0002\u0002\u0002\u0764\u077f\u0005\u0112\u008a',
+  '\u0002\u0765\u0767\u0007\u0099\u0002\u0002\u0766\u0765\u0003\u0002\u0002',
+  '\u0002\u0766\u0767\u0003\u0002\u0002\u0002\u0767\u0768\u0003\u0002\u0002',
+  '\u0002\u0768\u076a\u0007\u0019\u0002\u0002\u0769\u076b\u0007\u0099\u0002',
+  '\u0002\u076a\u0769\u0003\u0002\u0002\u0002\u076a\u076b\u0003\u0002\u0002',
+  '\u0002\u076b\u076c\u0003\u0002\u0002\u0002\u076c\u077e\u0005\u0112\u008a',
+  '\u0002\u076d\u076f\u0007\u0099\u0002\u0002\u076e\u076d\u0003\u0002\u0002',
+  '\u0002\u076e\u076f\u0003\u0002\u0002\u0002\u076f\u0770\u0003\u0002\u0002',
+  '\u0002\u0770\u0772\u0007\b\u0002\u0002\u0771\u0773\u0007\u0099\u0002',
+  '\u0002\u0772\u0771\u0003\u0002\u0002\u0002\u0772\u0773\u0003\u0002\u0002',
+  '\u0002\u0773\u0774\u0003\u0002\u0002\u0002\u0774\u077e\u0005\u0112\u008a',
+  '\u0002\u0775\u0777\u0007\u0099\u0002\u0002\u0776\u0775\u0003\u0002\u0002',
+  '\u0002\u0776\u0777\u0003\u0002\u0002\u0002\u0777\u0778\u0003\u0002\u0002',
+  '\u0002\u0778\u077a\u0007\u001b\u0002\u0002\u0779\u077b\u0007\u0099\u0002',
+  '\u0002\u077a\u0779\u0003\u0002\u0002\u0002\u077a\u077b\u0003\u0002\u0002',
+  '\u0002\u077b\u077c\u0003\u0002\u0002\u0002\u077c\u077e\u0005\u0112\u008a',
+  '\u0002\u077d\u0766\u0003\u0002\u0002\u0002\u077d\u076e\u0003\u0002\u0002',
+  '\u0002\u077d\u0776\u0003\u0002\u0002\u0002\u077e\u0781\u0003\u0002\u0002',
+  '\u0002\u077f\u077d\u0003\u0002\u0002\u0002\u077f\u0780\u0003\u0002\u0002',
+  '\u0002\u0780\u0111\u0003\u0002\u0002\u0002\u0781\u077f\u0003\u0002\u0002',
+  '\u0002\u0782\u078d\u0005\u0114\u008b\u0002\u0783\u0785\u0007\u0099\u0002',
+  '\u0002\u0784\u0783\u0003\u0002\u0002\u0002\u0784\u0785\u0003\u0002\u0002',
+  '\u0002\u0785\u0786\u0003\u0002\u0002\u0002\u0786\u0788\u0007\u001c\u0002',
+  '\u0002\u0787\u0789\u0007\u0099\u0002\u0002\u0788\u0787\u0003\u0002\u0002',
+  '\u0002\u0788\u0789\u0003\u0002\u0002\u0002\u0789\u078a\u0003\u0002\u0002',
+  '\u0002\u078a\u078c\u0005\u0114\u008b\u0002\u078b\u0784\u0003\u0002\u0002',
+  '\u0002\u078c\u078f\u0003\u0002\u0002\u0002\u078d\u078b\u0003\u0002\u0002',
+  '\u0002\u078d\u078e\u0003\u0002\u0002\u0002\u078e\u0113\u0003\u0002\u0002',
+  '\u0002\u078f\u078d\u0003\u0002\u0002\u0002\u0790\u0792\t\u0005\u0002',
+  '\u0002\u0791\u0793\u0007\u0099\u0002\u0002\u0792\u0791\u0003\u0002\u0002',
+  '\u0002\u0792\u0793\u0003\u0002\u0002\u0002\u0793\u0795\u0003\u0002\u0002',
+  '\u0002\u0794\u0790\u0003\u0002\u0002\u0002\u0795\u0798\u0003\u0002\u0002',
+  '\u0002\u0796\u0794\u0003\u0002\u0002\u0002\u0796\u0797\u0003\u0002\u0002',
+  '\u0002\u0797\u0799\u0003\u0002\u0002\u0002\u0798\u0796\u0003\u0002\u0002',
+  '\u0002\u0799\u079a\u0005\u0116\u008c\u0002\u079a\u0115\u0003\u0002\u0002',
+  '\u0002\u079b\u07d1\u0005\u0118\u008d\u0002\u079c\u079e\u0007\u0099\u0002',
+  '\u0002\u079d\u079c\u0003\u0002\u0002\u0002\u079d\u079e\u0003\u0002\u0002',
+  '\u0002\u079e\u079f\u0003\u0002\u0002\u0002\u079f\u07a0\u0007\u0013\u0002',
+  '\u0002\u07a0\u07a1\u0005\u0102\u0082\u0002\u07a1\u07a2\u0007\u0014\u0002',
+  '\u0002\u07a2\u07d0\u0003\u0002\u0002\u0002\u07a3\u07a5\u0007\u0099\u0002',
+  '\u0002\u07a4\u07a3\u0003\u0002\u0002\u0002\u07a4\u07a5\u0003\u0002\u0002',
+  '\u0002\u07a5\u07a6\u0003\u0002\u0002\u0002\u07a6\u07a8\u0007\u0013\u0002',
+  '\u0002\u07a7\u07a9\u0005\u0102\u0082\u0002\u07a8\u07a7\u0003\u0002\u0002',
+  '\u0002\u07a8\u07a9\u0003\u0002\u0002\u0002\u07a9\u07aa\u0003\u0002\u0002',
+  '\u0002\u07aa\u07ac\u0007\u001a\u0002\u0002\u07ab\u07ad\u0005\u0102\u0082',
+  '\u0002\u07ac\u07ab\u0003\u0002\u0002\u0002\u07ac\u07ad\u0003\u0002\u0002',
+  '\u0002\u07ad\u07ae\u0003\u0002\u0002\u0002\u07ae\u07d0\u0007\u0014\u0002',
+  '\u0002\u07af\u07b1\u0007\u0099\u0002\u0002\u07b0\u07af\u0003\u0002\u0002',
+  '\u0002\u07b0\u07b1\u0003\u0002\u0002\u0002\u07b1\u07b2\u0003\u0002\u0002',
+  '\u0002\u07b2\u07c0\u0007\u001d\u0002\u0002\u07b3\u07b4\u0007\u0099\u0002',
+  '\u0002\u07b4\u07c0\u0007Y\u0002\u0002\u07b5\u07b6\u0007\u0099\u0002',
+  '\u0002\u07b6\u07b7\u0007q\u0002\u0002\u07b7\u07b8\u0007\u0099\u0002',
+  '\u0002\u07b8\u07c0\u0007K\u0002\u0002\u07b9\u07ba\u0007\u0099\u0002',
+  '\u0002\u07ba\u07bb\u0007r\u0002\u0002\u07bb\u07bc\u0007\u0099\u0002',
+  '\u0002\u07bc\u07c0\u0007K\u0002\u0002\u07bd\u07be\u0007\u0099\u0002',
+  '\u0002\u07be\u07c0\u0007s\u0002\u0002\u07bf\u07b0\u0003\u0002\u0002',
+  '\u0002\u07bf\u07b3\u0003\u0002\u0002\u0002\u07bf\u07b5\u0003\u0002\u0002',
+  '\u0002\u07bf\u07b9\u0003\u0002\u0002\u0002\u07bf\u07bd\u0003\u0002\u0002',
+  '\u0002\u07c0\u07c2\u0003\u0002\u0002\u0002\u07c1\u07c3\u0007\u0099\u0002',
+  '\u0002\u07c2\u07c1\u0003\u0002\u0002\u0002\u07c2\u07c3\u0003\u0002\u0002',
+  '\u0002\u07c3\u07c4\u0003\u0002\u0002\u0002\u07c4\u07d0\u0005\u0118\u008d',
+  '\u0002\u07c5\u07c6\u0007\u0099\u0002\u0002\u07c6\u07c7\u0007F\u0002',
+  '\u0002\u07c7\u07c8\u0007\u0099\u0002\u0002\u07c8\u07d0\u0007t\u0002',
+  '\u0002\u07c9\u07ca\u0007\u0099\u0002\u0002\u07ca\u07cb\u0007F\u0002',
+  '\u0002\u07cb\u07cc\u0007\u0099\u0002\u0002\u07cc\u07cd\u0007p\u0002',
+  '\u0002\u07cd\u07ce\u0007\u0099\u0002\u0002\u07ce\u07d0\u0007t\u0002',
+  '\u0002\u07cf\u079d\u0003\u0002\u0002\u0002\u07cf\u07a4\u0003\u0002\u0002',
+  '\u0002\u07cf\u07bf\u0003\u0002\u0002\u0002\u07cf\u07c5\u0003\u0002\u0002',
+  '\u0002\u07cf\u07c9\u0003\u0002\u0002\u0002\u07d0\u07d3\u0003\u0002\u0002',
+  '\u0002\u07d1\u07cf\u0003\u0002\u0002\u0002\u07d1\u07d2\u0003\u0002\u0002',
+  '\u0002\u07d2\u0117\u0003\u0002\u0002\u0002\u07d3\u07d1\u0003\u0002\u0002',
+  '\u0002\u07d4\u07de\u0005\u0140\u00a1\u0002\u07d5\u07d7\u0007\u0099\u0002',
+  '\u0002\u07d6\u07d5\u0003\u0002\u0002\u0002\u07d6\u07d7\u0003\u0002\u0002',
+  '\u0002\u07d7\u07da\u0003\u0002\u0002\u0002\u07d8\u07db\u0005\u0160\u00b1',
+  '\u0002\u07d9\u07db\u0005\u00f8}\u0002\u07da\u07d8\u0003\u0002\u0002',
+  '\u0002\u07da\u07d9\u0003\u0002\u0002\u0002\u07db\u07dd\u0003\u0002\u0002',
+  '\u0002\u07dc\u07d6\u0003\u0002\u0002\u0002\u07dd\u07e0\u0003\u0002\u0002',
+  '\u0002\u07de\u07dc\u0003\u0002\u0002\u0002\u07de\u07df\u0003\u0002\u0002',
+  '\u0002\u07df\u0119\u0003\u0002\u0002\u0002\u07e0\u07de\u0003\u0002\u0002',
+  '\u0002\u07e1\u07e3\u0005\u011c\u008f\u0002\u07e2\u07e4\u0007\u0099\u0002',
+  '\u0002\u07e3\u07e2\u0003\u0002\u0002\u0002\u07e3\u07e4\u0003\u0002\u0002',
+  '\u0002\u07e4\u07e5\u0003\u0002\u0002\u0002\u07e5\u07e7\u0007\u0015\u0002',
+  '\u0002\u07e6\u07e8\u0007\u0099\u0002\u0002\u07e7\u07e6\u0003\u0002\u0002',
+  '\u0002\u07e7\u07e8\u0003\u0002\u0002\u0002\u07e8\u07e9\u0003\u0002\u0002',
+  '\u0002\u07e9\u07eb\u0005\u0150\u00a9\u0002\u07ea\u07ec\u0007\u0099\u0002',
+  '\u0002\u07eb\u07ea\u0003\u0002\u0002\u0002\u07eb\u07ec\u0003\u0002\u0002',
+  '\u0002\u07ec\u07ed\u0003\u0002\u0002\u0002\u07ed\u07ee\u0007\u0016\u0002',
+  '\u0002\u07ee\u011b\u0003\u0002\u0002\u0002\u07ef\u07f0\u0007v\u0002',
+  '\u0002\u07f0\u011d\u0003\u0002\u0002\u0002\u07f1\u07f3\u0005\u0120\u0091',
+  '\u0002\u07f2\u07f4\u0007\u0099\u0002\u0002\u07f3\u07f2\u0003\u0002\u0002',
+  '\u0002\u07f3\u07f4\u0003\u0002\u0002\u0002\u07f4\u07f5\u0003\u0002\u0002',
+  '\u0002\u07f5\u07f7\u0007\u0015\u0002\u0002\u07f6\u07f8\u0007\u0099\u0002',
+  '\u0002\u07f7\u07f6\u0003\u0002\u0002\u0002\u07f7\u07f8\u0003\u0002\u0002',
+  '\u0002\u07f8\u07f9\u0003\u0002\u0002\u0002\u07f9\u07fb\u0005\u0102\u0082',
+  '\u0002\u07fa\u07fc\u0007\u0099\u0002\u0002\u07fb\u07fa\u0003\u0002\u0002',
+  '\u0002\u07fb\u07fc\u0003\u0002\u0002\u0002\u07fc\u07fd\u0003\u0002\u0002',
+  '\u0002\u07fd\u07fe\u0007\u0016\u0002\u0002\u07fe\u011f\u0003\u0002\u0002',
+  '\u0002\u07ff\u0800\u0007H\u0002\u0002\u0800\u0121\u0003\u0002\u0002',
+  '\u0002\u0801\u0803\u0005\u0124\u0093\u0002\u0802\u0804\u0007\u0099\u0002',
+  '\u0002\u0803\u0802\u0003\u0002\u0002\u0002\u0803\u0804\u0003\u0002\u0002',
+  '\u0002\u0804\u0805\u0003\u0002\u0002\u0002\u0805\u0807\u0007\u0015\u0002',
+  '\u0002\u0806\u0808\u0007\u0099\u0002\u0002\u0807\u0806\u0003\u0002\u0002',
+  '\u0002\u0807\u0808\u0003\u0002\u0002\u0002\u0808\u0809\u0003\u0002\u0002',
+  '\u0002\u0809\u080b\u0005\u0150\u00a9\u0002\u080a\u080c\u0007\u0099\u0002',
+  '\u0002\u080b\u080a\u0003\u0002\u0002\u0002\u080b\u080c\u0003\u0002\u0002',
+  '\u0002\u080c\u080d\u0003\u0002\u0002\u0002\u080d\u080e\u0007\u0016\u0002',
+  '\u0002\u080e\u0123\u0003\u0002\u0002\u0002\u080f\u0810\u0007?\u0002',
+  '\u0002\u0810\u0125\u0003\u0002\u0002\u0002\u0811\u0813\u0005\u0128\u0095',
+  '\u0002\u0812\u0814\u0007\u0099\u0002\u0002\u0813\u0812\u0003\u0002\u0002',
+  '\u0002\u0813\u0814\u0003\u0002\u0002\u0002\u0814\u0815\u0003\u0002\u0002',
+  '\u0002\u0815\u0817\u0007\u0015\u0002\u0002\u0816\u0818\u0007\u0099\u0002',
+  '\u0002\u0817\u0816\u0003\u0002\u0002\u0002\u0817\u0818\u0003\u0002\u0002',
+  '\u0002\u0818\u0819\u0003\u0002\u0002\u0002\u0819\u081b\u0005\u0150\u00a9',
+  '\u0002\u081a\u081c\u0007\u0099\u0002\u0002\u081b\u081a\u0003\u0002\u0002',
+  '\u0002\u081b\u081c\u0003\u0002\u0002\u0002\u081c\u081d\u0003\u0002\u0002',
+  '\u0002\u081d\u081e\u0007\u0016\u0002\u0002\u081e\u0127\u0003\u0002\u0002',
+  '\u0002\u081f\u0820\u0007x\u0002\u0002\u0820\u0129\u0003\u0002\u0002',
+  '\u0002\u0821\u0823\u0005\u012c\u0097\u0002\u0822\u0824\u0007\u0099\u0002',
+  '\u0002\u0823\u0822\u0003\u0002\u0002\u0002\u0823\u0824\u0003\u0002\u0002',
+  '\u0002\u0824\u0825\u0003\u0002\u0002\u0002\u0825\u0827\u0007\u0015\u0002',
+  '\u0002\u0826\u0828\u0007\u0099\u0002\u0002\u0827\u0826\u0003\u0002\u0002',
+  '\u0002\u0827\u0828\u0003\u0002\u0002\u0002\u0828\u0829\u0003\u0002\u0002',
+  '\u0002\u0829\u082b\u0005\u0150\u00a9\u0002\u082a\u082c\u0007\u0099\u0002',
+  '\u0002\u082b\u082a\u0003\u0002\u0002\u0002\u082b\u082c\u0003\u0002\u0002',
+  '\u0002\u082c\u082d\u0003\u0002\u0002\u0002\u082d\u082e\u0007\u0016\u0002',
+  '\u0002\u082e\u012b\u0003\u0002\u0002\u0002\u082f\u0830\u0007y\u0002',
+  '\u0002\u0830\u012d\u0003\u0002\u0002\u0002\u0831\u0833\u0005\u0130\u0099',
+  '\u0002\u0832\u0834\u0007\u0099\u0002\u0002\u0833\u0832\u0003\u0002\u0002',
+  '\u0002\u0833\u0834\u0003\u0002\u0002\u0002\u0834\u0835\u0003\u0002\u0002',
+  '\u0002\u0835\u0837\u0007\u0015\u0002\u0002\u0836\u0838\u0007\u0099\u0002',
+  '\u0002\u0837\u0836\u0003\u0002\u0002\u0002\u0837\u0838\u0003\u0002\u0002',
+  '\u0002\u0838\u0839\u0003\u0002\u0002\u0002\u0839\u083b\u0005\u0150\u00a9',
+  '\u0002\u083a\u083c\u0007\u0099\u0002\u0002\u083b\u083a\u0003\u0002\u0002',
+  '\u0002\u083b\u083c\u0003\u0002\u0002\u0002\u083c\u083d\u0003\u0002\u0002',
+  '\u0002\u083d\u083e\u0007\u0016\u0002\u0002\u083e\u012f\u0003\u0002\u0002',
+  '\u0002\u083f\u0840\u0007z\u0002\u0002\u0840\u0131\u0003\u0002\u0002',
+  '\u0002\u0841\u0843\u0005\u0134\u009b\u0002\u0842\u0844\u0007\u0099\u0002',
+  '\u0002\u0843\u0842\u0003\u0002\u0002\u0002\u0843\u0844\u0003\u0002\u0002',
+  '\u0002\u0844\u0845\u0003\u0002\u0002\u0002\u0845\u0847\u0007\u0015\u0002',
+  '\u0002\u0846\u0848\u0007\u0099\u0002\u0002\u0847\u0846\u0003\u0002\u0002',
+  '\u0002\u0847\u0848\u0003\u0002\u0002\u0002\u0848\u0849\u0003\u0002\u0002',
+  '\u0002\u0849\u0852\u0005\u0150\u00a9\u0002\u084a\u084c\u0007\u0099\u0002',
+  '\u0002\u084b\u084a\u0003\u0002\u0002\u0002\u084b\u084c\u0003\u0002\u0002',
+  '\u0002\u084c\u084d\u0003\u0002\u0002\u0002\u084d\u084f\u0007\u0018\u0002',
+  '\u0002\u084e\u0850\u0007\u0099\u0002\u0002\u084f\u084e\u0003\u0002\u0002',
+  '\u0002\u084f\u0850\u0003\u0002\u0002\u0002\u0850\u0851\u0003\u0002\u0002',
+  '\u0002\u0851\u0853\u0005\u0102\u0082\u0002\u0852\u084b\u0003\u0002\u0002',
+  '\u0002\u0852\u0853\u0003\u0002\u0002\u0002\u0853\u0855\u0003\u0002\u0002',
+  '\u0002\u0854\u0856\u0007\u0099\u0002\u0002\u0855\u0854\u0003\u0002\u0002',
+  '\u0002\u0855\u0856\u0003\u0002\u0002\u0002\u0856\u0857\u0003\u0002\u0002',
+  '\u0002\u0857\u0858\u0007\u0016\u0002\u0002\u0858\u0133\u0003\u0002\u0002',
+  '\u0002\u0859\u085a\u0007w\u0002\u0002\u085a\u0135\u0003\u0002\u0002',
+  '\u0002\u085b\u085d\u0005\u0138\u009d\u0002\u085c\u085e\u0007\u0099\u0002',
+  '\u0002\u085d\u085c\u0003\u0002\u0002\u0002\u085d\u085e\u0003\u0002\u0002',
+  '\u0002\u085e\u085f\u0003\u0002\u0002\u0002\u085f\u0861\u0007\u0015\u0002',
+  '\u0002\u0860\u0862\u0007\u0099\u0002\u0002\u0861\u0860\u0003\u0002\u0002',
+  '\u0002\u0861\u0862\u0003\u0002\u0002\u0002\u0862\u0863\u0003\u0002\u0002',
+  '\u0002\u0863\u0865\u0005\u0166\u00b4\u0002\u0864\u0866\u0007\u0099\u0002',
+  '\u0002\u0865\u0864\u0003\u0002\u0002\u0002\u0865\u0866\u0003\u0002\u0002',
+  '\u0002\u0866\u0867\u0003\u0002\u0002\u0002\u0867\u0869\u0007\u000e\u0002',
+  '\u0002\u0868\u086a\u0007\u0099\u0002\u0002\u0869\u0868\u0003\u0002\u0002',
+  '\u0002\u0869\u086a\u0003\u0002\u0002\u0002\u086a\u086b\u0003\u0002\u0002',
+  '\u0002\u086b\u086d\u0005\u0102\u0082\u0002\u086c\u086e\u0007\u0099\u0002',
+  '\u0002\u086d\u086c\u0003\u0002\u0002\u0002\u086d\u086e\u0003\u0002\u0002',
+  '\u0002\u086e\u086f\u0003\u0002\u0002\u0002\u086f\u0871\u0007\u0011\u0002',
+  '\u0002\u0870\u0872\u0007\u0099\u0002\u0002\u0871\u0870\u0003\u0002\u0002',
+  '\u0002\u0871\u0872\u0003\u0002\u0002\u0002\u0872\u0873\u0003\u0002\u0002',
+  '\u0002\u0873\u0875\u0005\u0152\u00aa\u0002\u0874\u0876\u0007\u0099\u0002',
+  '\u0002\u0875\u0874\u0003\u0002\u0002\u0002\u0875\u0876\u0003\u0002\u0002',
+  '\u0002\u0876\u0877\u0003\u0002\u0002\u0002\u0877\u0879\u0007\u0018\u0002',
+  '\u0002\u0878\u087a\u0007\u0099\u0002\u0002\u0879\u0878\u0003\u0002\u0002',
+  '\u0002\u0879\u087a\u0003\u0002\u0002\u0002\u087a\u087b\u0003\u0002\u0002',
+  '\u0002\u087b\u087d\u0005\u0102\u0082\u0002\u087c\u087e\u0007\u0099\u0002',
+  '\u0002\u087d\u087c\u0003\u0002\u0002\u0002\u087d\u087e\u0003\u0002\u0002',
+  '\u0002\u087e\u087f\u0003\u0002\u0002\u0002\u087f\u0880\u0007\u0016\u0002',
+  '\u0002\u0880\u0137\u0003\u0002\u0002\u0002\u0881\u0882\u0007}\u0002',
+  '\u0002\u0882\u0139\u0003\u0002\u0002\u0002\u0883\u0885\u0005\u013c\u009f',
+  '\u0002\u0884\u0886\u0007\u0099\u0002\u0002\u0885\u0884\u0003\u0002\u0002',
+  '\u0002\u0885\u0886\u0003\u0002\u0002\u0002\u0886\u0887\u0003\u0002\u0002',
+  '\u0002\u0887\u0889\u0007\u0015\u0002\u0002\u0888\u088a\u0007\u0099\u0002',
+  '\u0002\u0889\u0888\u0003\u0002\u0002\u0002\u0889\u088a\u0003\u0002\u0002',
+  '\u0002\u088a\u088b\u0003\u0002\u0002\u0002\u088b\u088d\u0005\u00e0q',
+  '\u0002\u088c\u088e\u0007\u0099\u0002\u0002\u088d\u088c\u0003\u0002\u0002',
+  '\u0002\u088d\u088e\u0003\u0002\u0002\u0002\u088e\u088f\u0003\u0002\u0002',
+  '\u0002\u088f\u0890\u0007\u0016\u0002\u0002\u0890\u08a0\u0003\u0002\u0002',
+  '\u0002\u0891\u0893\u0005\u013e\u00a0\u0002\u0892\u0894\u0007\u0099\u0002',
+  '\u0002\u0893\u0892\u0003\u0002\u0002\u0002\u0893\u0894\u0003\u0002\u0002',
+  '\u0002\u0894\u0895\u0003\u0002\u0002\u0002\u0895\u0897\u0007\u0015\u0002',
+  '\u0002\u0896\u0898\u0007\u0099\u0002\u0002\u0897\u0896\u0003\u0002\u0002',
+  '\u0002\u0897\u0898\u0003\u0002\u0002\u0002\u0898\u0899\u0003\u0002\u0002',
+  '\u0002\u0899\u089b\u0005\u00e0q\u0002\u089a\u089c\u0007\u0099\u0002',
+  '\u0002\u089b\u089a\u0003\u0002\u0002\u0002\u089b\u089c\u0003\u0002\u0002',
+  '\u0002\u089c\u089d\u0003\u0002\u0002\u0002\u089d\u089e\u0007\u0016\u0002',
+  '\u0002\u089e\u08a0\u0003\u0002\u0002\u0002\u089f\u0883\u0003\u0002\u0002',
+  '\u0002\u089f\u0891\u0003\u0002\u0002\u0002\u08a0\u013b\u0003\u0002\u0002',
+  '\u0002\u08a1\u08a2\u0007k\u0002\u0002\u08a2\u013d\u0003\u0002\u0002',
+  '\u0002\u08a3\u08a4\u0007l\u0002\u0002\u08a4\u013f\u0003\u0002\u0002',
+  '\u0002\u08a5\u08c5\u0005\u0142\u00a2\u0002\u08a6\u08c5\u0005\u0178\u00bd',
+  '\u0002\u08a7\u08c5\u0005\u0162\u00b2\u0002\u08a8\u08aa\u0007u\u0002',
+  '\u0002\u08a9\u08ab\u0007\u0099\u0002\u0002\u08aa\u08a9\u0003\u0002\u0002',
+  '\u0002\u08aa\u08ab\u0003\u0002\u0002\u0002\u08ab\u08ac\u0003\u0002\u0002',
+  '\u0002\u08ac\u08ae\u0007\u0015\u0002\u0002\u08ad\u08af\u0007\u0099\u0002',
+  '\u0002\u08ae\u08ad\u0003\u0002\u0002\u0002\u08ae\u08af\u0003\u0002\u0002',
+  '\u0002\u08af\u08b0\u0003\u0002\u0002\u0002\u08b0\u08b2\u0007\u0019\u0002',
+  '\u0002\u08b1\u08b3\u0007\u0099\u0002\u0002\u08b2\u08b1\u0003\u0002\u0002',
+  '\u0002\u08b2\u08b3\u0003\u0002\u0002\u0002\u08b3\u08b4\u0003\u0002\u0002',
+  '\u0002\u08b4\u08c5\u0007\u0016\u0002\u0002\u08b5\u08c5\u0005\u015c\u00af',
+  '\u0002\u08b6\u08c5\u0005\u015e\u00b0\u0002\u08b7\u08c5\u0005\u011a\u008e',
+  '\u0002\u08b8\u08c5\u0005\u0132\u009a\u0002\u08b9\u08c5\u0005\u0136\u009c',
+  '\u0002\u08ba\u08c5\u0005\u0122\u0092\u0002\u08bb\u08c5\u0005\u0126\u0094',
+  '\u0002\u08bc\u08c5\u0005\u012a\u0096\u0002\u08bd\u08c5\u0005\u012e\u0098',
+  '\u0002\u08be\u08c5\u0005\u011e\u0090\u0002\u08bf\u08c5\u0005\u013a\u009e',
+  '\u0002\u08c0\u08c5\u0005\u014e\u00a8\u0002\u08c1\u08c5\u0005\u014c\u00a7',
+  '\u0002\u08c2\u08c5\u0005\u0154\u00ab\u0002\u08c3\u08c5\u0005\u0166\u00b4',
+  '\u0002\u08c4\u08a5\u0003\u0002\u0002\u0002\u08c4\u08a6\u0003\u0002\u0002',
+  '\u0002\u08c4\u08a7\u0003\u0002\u0002\u0002\u08c4\u08a8\u0003\u0002\u0002',
+  '\u0002\u08c4\u08b5\u0003\u0002\u0002\u0002\u08c4\u08b6\u0003\u0002\u0002',
+  '\u0002\u08c4\u08b7\u0003\u0002\u0002\u0002\u08c4\u08b8\u0003\u0002\u0002',
+  '\u0002\u08c4\u08b9\u0003\u0002\u0002\u0002\u08c4\u08ba\u0003\u0002\u0002',
+  '\u0002\u08c4\u08bb\u0003\u0002\u0002\u0002\u08c4\u08bc\u0003\u0002\u0002',
+  '\u0002\u08c4\u08bd\u0003\u0002\u0002\u0002\u08c4\u08be\u0003\u0002\u0002',
+  '\u0002\u08c4\u08bf\u0003\u0002\u0002\u0002\u08c4\u08c0\u0003\u0002\u0002',
+  '\u0002\u08c4\u08c1\u0003\u0002\u0002\u0002\u08c4\u08c2\u0003\u0002\u0002',
+  '\u0002\u08c4\u08c3\u0003\u0002\u0002\u0002\u08c5\u0141\u0003\u0002\u0002',
+  '\u0002\u08c6\u08ce\u0005\u0168\u00b5\u0002\u08c7\u08ce\u0005\u0144\u00a3',
+  '\u0002\u08c8\u08ce\u0005\u0146\u00a4\u0002\u08c9\u08ce\u0007t\u0002',
+  '\u0002\u08ca\u08ce\u0005\u016a\u00b6\u0002\u08cb\u08ce\u0005\u0148\u00a5',
+  '\u0002\u08cc\u08ce\u0005\u016c\u00b7\u0002\u08cd\u08c6\u0003\u0002\u0002',
+  '\u0002\u08cd\u08c7\u0003\u0002\u0002\u0002\u08cd\u08c8\u0003\u0002\u0002',
+  '\u0002\u08cd\u08c9\u0003\u0002\u0002\u0002\u08cd\u08ca\u0003\u0002\u0002',
+  '\u0002\u08cd\u08cb\u0003\u0002\u0002\u0002\u08cd\u08cc\u0003\u0002\u0002',
+  '\u0002\u08ce\u0143\u0003\u0002\u0002\u0002\u08cf\u08d0\u0007\u0086\u0002',
+  '\u0002\u08d0\u0145\u0003\u0002\u0002\u0002\u08d1\u08d2\t\u0006\u0002',
+  '\u0002\u08d2\u0147\u0003\u0002\u0002\u0002\u08d3\u08d5\u0007\u0013\u0002',
+  '\u0002\u08d4\u08d6\u0007\u0099\u0002\u0002\u08d5\u08d4\u0003\u0002\u0002',
+  '\u0002\u08d5\u08d6\u0003\u0002\u0002\u0002\u08d6\u08e8\u0003\u0002\u0002',
+  '\u0002\u08d7\u08d9\u0005\u0102\u0082\u0002\u08d8\u08da\u0007\u0099\u0002',
+  '\u0002\u08d9\u08d8\u0003\u0002\u0002\u0002\u08d9\u08da\u0003\u0002\u0002',
+  '\u0002\u08da\u08e5\u0003\u0002\u0002\u0002\u08db\u08dd\u0007\u0011\u0002',
+  '\u0002\u08dc\u08de\u0007\u0099\u0002\u0002\u08dd\u08dc\u0003\u0002\u0002',
+  '\u0002\u08dd\u08de\u0003\u0002\u0002\u0002\u08de\u08df\u0003\u0002\u0002',
+  '\u0002\u08df\u08e1\u0005\u0102\u0082\u0002\u08e0\u08e2\u0007\u0099\u0002',
+  '\u0002\u08e1\u08e0\u0003\u0002\u0002\u0002\u08e1\u08e2\u0003\u0002\u0002',
+  '\u0002\u08e2\u08e4\u0003\u0002\u0002\u0002\u08e3\u08db\u0003\u0002\u0002',
+  '\u0002\u08e4\u08e7\u0003\u0002\u0002\u0002\u08e5\u08e3\u0003\u0002\u0002',
+  '\u0002\u08e5\u08e6\u0003\u0002\u0002\u0002\u08e6\u08e9\u0003\u0002\u0002',
+  '\u0002\u08e7\u08e5\u0003\u0002\u0002\u0002\u08e8\u08d7\u0003\u0002\u0002',
+  '\u0002\u08e8\u08e9\u0003\u0002\u0002\u0002\u08e9\u08ea\u0003\u0002\u0002',
+  '\u0002\u08ea\u08eb\u0007\u0014\u0002\u0002\u08eb\u0149\u0003\u0002\u0002',
+  '\u0002\u08ec\u08ee\u0007\u000e\u0002\u0002\u08ed\u08ef\u0007\u0099\u0002',
+  '\u0002\u08ee\u08ed\u0003\u0002\u0002\u0002\u08ee\u08ef\u0003\u0002\u0002',
+  '\u0002\u08ef\u08f0\u0003\u0002\u0002\u0002\u08f0\u0910\u0005\u010e\u0088',
+  '\u0002\u08f1\u08f3\u0007\u001e\u0002\u0002\u08f2\u08f4\u0007\u0099\u0002',
+  '\u0002\u08f3\u08f2\u0003\u0002\u0002\u0002\u08f3\u08f4\u0003\u0002\u0002',
+  '\u0002\u08f4\u08f5\u0003\u0002\u0002\u0002\u08f5\u0910\u0005\u010e\u0088',
+  '\u0002\u08f6\u08f8\u0007\u001f\u0002\u0002\u08f7\u08f9\u0007\u0099\u0002',
+  '\u0002\u08f8\u08f7\u0003\u0002\u0002\u0002\u08f8\u08f9\u0003\u0002\u0002',
+  '\u0002\u08f9\u08fa\u0003\u0002\u0002\u0002\u08fa\u0910\u0005\u010e\u0088',
+  '\u0002\u08fb\u08fd\u0007 \u0002\u0002\u08fc\u08fe\u0007\u0099\u0002',
+  '\u0002\u08fd\u08fc\u0003\u0002\u0002\u0002\u08fd\u08fe\u0003\u0002\u0002',
+  '\u0002\u08fe\u08ff\u0003\u0002\u0002\u0002\u08ff\u0910\u0005\u010e\u0088',
+  '\u0002\u0900\u0902\u0007!\u0002\u0002\u0901\u0903\u0007\u0099\u0002',
+  '\u0002\u0902\u0901\u0003\u0002\u0002\u0002\u0902\u0903\u0003\u0002\u0002',
+  '\u0002\u0903\u0904\u0003\u0002\u0002\u0002\u0904\u0910\u0005\u010e\u0088',
+  '\u0002\u0905\u0907\u0007"\u0002\u0002\u0906\u0908\u0007\u0099\u0002',
+  '\u0002\u0907\u0906\u0003\u0002\u0002\u0002\u0907\u0908\u0003\u0002\u0002',
+  '\u0002\u0908\u0909\u0003\u0002\u0002\u0002\u0909\u0910\u0005\u010e\u0088',
+  '\u0002\u090a\u090c\u0007#\u0002\u0002\u090b\u090d\u0007\u0099\u0002',
+  '\u0002\u090c\u090b\u0003\u0002\u0002\u0002\u090c\u090d\u0003\u0002\u0002',
+  '\u0002\u090d\u090e\u0003\u0002\u0002\u0002\u090e\u0910\u0005\u010e\u0088',
+  '\u0002\u090f\u08ec\u0003\u0002\u0002\u0002\u090f\u08f1\u0003\u0002\u0002',
+  '\u0002\u090f\u08f6\u0003\u0002\u0002\u0002\u090f\u08fb\u0003\u0002\u0002',
+  '\u0002\u090f\u0900\u0003\u0002\u0002\u0002\u090f\u0905\u0003\u0002\u0002',
+  '\u0002\u090f\u090a\u0003\u0002\u0002\u0002\u0910\u014b\u0003\u0002\u0002',
+  '\u0002\u0911\u0913\u0007\u0015\u0002\u0002\u0912\u0914\u0007\u0099\u0002',
+  '\u0002\u0913\u0912\u0003\u0002\u0002\u0002\u0913\u0914\u0003\u0002\u0002',
+  '\u0002\u0914\u0915\u0003\u0002\u0002\u0002\u0915\u0917\u0005\u0102\u0082',
+  '\u0002\u0916\u0918\u0007\u0099\u0002\u0002\u0917\u0916\u0003\u0002\u0002',
+  '\u0002\u0917\u0918\u0003\u0002\u0002\u0002\u0918\u0919\u0003\u0002\u0002',
+  '\u0002\u0919\u091a\u0007\u0016\u0002\u0002\u091a\u014d\u0003\u0002\u0002',
+  '\u0002\u091b\u0920\u0005\u00e2r\u0002\u091c\u091e\u0007\u0099\u0002',
+  '\u0002\u091d\u091c\u0003\u0002\u0002\u0002\u091d\u091e\u0003\u0002\u0002',
+  '\u0002\u091e\u091f\u0003\u0002\u0002\u0002\u091f\u0921\u0005\u00e4s',
+  '\u0002\u0920\u091d\u0003\u0002\u0002\u0002\u0921\u0922\u0003\u0002\u0002',
+  '\u0002\u0922\u0920\u0003\u0002\u0002\u0002\u0922\u0923\u0003\u0002\u0002',
+  '\u0002\u0923\u014f\u0003\u0002\u0002\u0002\u0924\u0929\u0005\u0152\u00aa',
+  '\u0002\u0925\u0927\u0007\u0099\u0002\u0002\u0926\u0925\u0003\u0002\u0002',
+  '\u0002\u0926\u0927\u0003\u0002\u0002\u0002\u0927\u0928\u0003\u0002\u0002',
+  '\u0002\u0928\u092a\u0005\u00d8m\u0002\u0929\u0926\u0003\u0002\u0002',
+  '\u0002\u0929\u092a\u0003\u0002\u0002\u0002\u092a\u0151\u0003\u0002\u0002',
+  '\u0002\u092b\u092c\u0005\u0166\u00b4\u0002\u092c\u092d\u0007\u0099\u0002',
+  '\u0002\u092d\u092e\u0007Y\u0002\u0002\u092e\u092f\u0007\u0099\u0002',
+  '\u0002\u092f\u0930\u0005\u0102\u0082\u0002\u0930\u0153\u0003\u0002\u0002',
+  '\u0002\u0931\u0933\u0005\u0156\u00ac\u0002\u0932\u0934\u0007\u0099\u0002',
+  '\u0002\u0933\u0932\u0003\u0002\u0002\u0002\u0933\u0934\u0003\u0002\u0002',
+  '\u0002\u0934\u0935\u0003\u0002\u0002\u0002\u0935\u0937\u0007\u0015\u0002',
+  '\u0002\u0936\u0938\u0007\u0099\u0002\u0002\u0937\u0936\u0003\u0002\u0002',
+  '\u0002\u0937\u0938\u0003\u0002\u0002\u0002\u0938\u093d\u0003\u0002\u0002',
+  '\u0002\u0939\u093b\u0007Z\u0002\u0002\u093a\u093c\u0007\u0099\u0002',
+  '\u0002\u093b\u093a\u0003\u0002\u0002\u0002\u093b\u093c\u0003\u0002\u0002',
+  '\u0002\u093c\u093e\u0003\u0002\u0002\u0002\u093d\u0939\u0003\u0002\u0002',
+  '\u0002\u093d\u093e\u0003\u0002\u0002\u0002\u093e\u0950\u0003\u0002\u0002',
+  '\u0002\u093f\u0941\u0005\u0102\u0082\u0002\u0940\u0942\u0007\u0099\u0002',
+  '\u0002\u0941\u0940\u0003\u0002\u0002\u0002\u0941\u0942\u0003\u0002\u0002',
+  '\u0002\u0942\u094d\u0003\u0002\u0002\u0002\u0943\u0945\u0007\u0011\u0002',
+  '\u0002\u0944\u0946\u0007\u0099\u0002\u0002\u0945\u0944\u0003\u0002\u0002',
+  '\u0002\u0945\u0946\u0003\u0002\u0002\u0002\u0946\u0947\u0003\u0002\u0002',
+  '\u0002\u0947\u0949\u0005\u0102\u0082\u0002\u0948\u094a\u0007\u0099\u0002',
+  '\u0002\u0949\u0948\u0003\u0002\u0002\u0002\u0949\u094a\u0003\u0002\u0002',
+  '\u0002\u094a\u094c\u0003\u0002\u0002\u0002\u094b\u0943\u0003\u0002\u0002',
+  '\u0002\u094c\u094f\u0003\u0002\u0002\u0002\u094d\u094b\u0003\u0002\u0002',
+  '\u0002\u094d\u094e\u0003\u0002\u0002\u0002\u094e\u0951\u0003\u0002\u0002',
+  '\u0002\u094f\u094d\u0003\u0002\u0002\u0002\u0950\u093f\u0003\u0002\u0002',
+  '\u0002\u0950\u0951\u0003\u0002\u0002\u0002\u0951\u0952\u0003\u0002\u0002',
+  '\u0002\u0952\u0953\u0007\u0016\u0002\u0002\u0953\u0155\u0003\u0002\u0002',
+  '\u0002\u0954\u0955\u0005\u018c\u00c7\u0002\u0955\u0956\u0005\u0158\u00ad',
+  '\u0002\u0956\u0157\u0003\u0002\u0002\u0002\u0957\u0958\t\u0007\u0002',
+  '\u0002\u0958\u0159\u0003\u0002\u0002\u0002\u0959\u095a\u0005\u0194\u00cb',
+  '\u0002\u095a\u015b\u0003\u0002\u0002\u0002\u095b\u095d\u0007\u0013\u0002',
+  '\u0002\u095c\u095e\u0007\u0099\u0002\u0002\u095d\u095c\u0003\u0002\u0002',
+  '\u0002\u095d\u095e\u0003\u0002\u0002\u0002\u095e\u095f\u0003\u0002\u0002',
+  '\u0002\u095f\u0968\u0005\u0150\u00a9\u0002\u0960\u0962\u0007\u0099\u0002',
+  '\u0002\u0961\u0960\u0003\u0002\u0002\u0002\u0961\u0962\u0003\u0002\u0002',
+  '\u0002\u0962\u0963\u0003\u0002\u0002\u0002\u0963\u0965\u0007\u0018\u0002',
+  '\u0002\u0964\u0966\u0007\u0099\u0002\u0002\u0965\u0964\u0003\u0002\u0002',
+  '\u0002\u0965\u0966\u0003\u0002\u0002\u0002\u0966\u0967\u0003\u0002\u0002',
+  '\u0002\u0967\u0969\u0005\u0102\u0082\u0002\u0968\u0961\u0003\u0002\u0002',
+  '\u0002\u0968\u0969\u0003\u0002\u0002\u0002\u0969\u096b\u0003\u0002\u0002',
+  '\u0002\u096a\u096c\u0007\u0099\u0002\u0002\u096b\u096a\u0003\u0002\u0002',
+  '\u0002\u096b\u096c\u0003\u0002\u0002\u0002\u096c\u096d\u0003\u0002\u0002',
+  '\u0002\u096d\u096e\u0007\u0014\u0002\u0002\u096e\u015d\u0003\u0002\u0002',
+  '\u0002\u096f\u0971\u0007\u0013\u0002\u0002\u0970\u0972\u0007\u0099\u0002',
+  '\u0002\u0971\u0970\u0003\u0002\u0002\u0002\u0971\u0972\u0003\u0002\u0002',
+  '\u0002\u0972\u097b\u0003\u0002\u0002\u0002\u0973\u0975\u0005\u0166\u00b4',
+  '\u0002\u0974\u0976\u0007\u0099\u0002\u0002\u0975\u0974\u0003\u0002\u0002',
+  '\u0002\u0975\u0976\u0003\u0002\u0002\u0002\u0976\u0977\u0003\u0002\u0002',
+  '\u0002\u0977\u0979\u0007\u000e\u0002\u0002\u0978\u097a\u0007\u0099\u0002',
+  '\u0002\u0979\u0978\u0003\u0002\u0002\u0002\u0979\u097a\u0003\u0002\u0002',
+  '\u0002\u097a\u097c\u0003\u0002\u0002\u0002\u097b\u0973\u0003\u0002\u0002',
+  '\u0002\u097b\u097c\u0003\u0002\u0002\u0002\u097c\u097d\u0003\u0002\u0002',
+  '\u0002\u097d\u097f\u0005\u014e\u00a8\u0002\u097e\u0980\u0007\u0099\u0002',
+  '\u0002\u097f\u097e\u0003\u0002\u0002\u0002\u097f\u0980\u0003\u0002\u0002',
+  '\u0002\u0980\u0989\u0003\u0002\u0002\u0002\u0981\u0983\u0007j\u0002',
+  '\u0002\u0982\u0984\u0007\u0099\u0002\u0002\u0983\u0982\u0003\u0002\u0002',
+  '\u0002\u0983\u0984\u0003\u0002\u0002\u0002\u0984\u0985\u0003\u0002\u0002',
+  '\u0002\u0985\u0987\u0005\u0102\u0082\u0002\u0986\u0988\u0007\u0099\u0002',
+  '\u0002\u0987\u0986\u0003\u0002\u0002\u0002\u0987\u0988\u0003\u0002\u0002',
+  '\u0002\u0988\u098a\u0003\u0002\u0002\u0002\u0989\u0981\u0003\u0002\u0002',
+  '\u0002\u0989\u098a\u0003\u0002\u0002\u0002\u098a\u098b\u0003\u0002\u0002',
+  '\u0002\u098b\u098d\u0007\u0018\u0002\u0002\u098c\u098e\u0007\u0099\u0002',
+  '\u0002\u098d\u098c\u0003\u0002\u0002\u0002\u098d\u098e\u0003\u0002\u0002',
+  '\u0002\u098e\u098f\u0003\u0002\u0002\u0002\u098f\u0991\u0005\u0102\u0082',
+  '\u0002\u0990\u0992\u0007\u0099\u0002\u0002\u0991\u0990\u0003\u0002\u0002',
+  '\u0002\u0991\u0992\u0003\u0002\u0002\u0002\u0992\u0993\u0003\u0002\u0002',
+  '\u0002\u0993\u0994\u0007\u0014\u0002\u0002\u0994\u015f\u0003\u0002\u0002',
+  '\u0002\u0995\u0997\u0007\t\u0002\u0002\u0996\u0998\u0007\u0099\u0002',
+  '\u0002\u0997\u0996\u0003\u0002\u0002\u0002\u0997\u0998\u0003\u0002\u0002',
+  '\u0002\u0998\u0999\u0003\u0002\u0002\u0002\u0999\u099a\u0005\u0186\u00c4',
+  '\u0002\u099a\u0161\u0003\u0002\u0002\u0002\u099b\u09a0\u0007~\u0002',
+  '\u0002\u099c\u099e\u0007\u0099\u0002\u0002\u099d\u099c\u0003\u0002\u0002',
+  '\u0002\u099d\u099e\u0003\u0002\u0002\u0002\u099e\u099f\u0003\u0002\u0002',
+  '\u0002\u099f\u09a1\u0005\u0164\u00b3\u0002\u09a0\u099d\u0003\u0002\u0002',
+  '\u0002\u09a1\u09a2\u0003\u0002\u0002\u0002\u09a2\u09a0\u0003\u0002\u0002',
+  '\u0002\u09a2\u09a3\u0003\u0002\u0002\u0002\u09a3\u09b2\u0003\u0002\u0002',
+  '\u0002\u09a4\u09a6\u0007~\u0002\u0002\u09a5\u09a7\u0007\u0099\u0002',
+  '\u0002\u09a6\u09a5\u0003\u0002\u0002\u0002\u09a6\u09a7\u0003\u0002\u0002',
+  '\u0002\u09a7\u09a8\u0003\u0002\u0002\u0002\u09a8\u09ad\u0005\u0102\u0082',
+  '\u0002\u09a9\u09ab\u0007\u0099\u0002\u0002\u09aa\u09a9\u0003\u0002\u0002',
+  '\u0002\u09aa\u09ab\u0003\u0002\u0002\u0002\u09ab\u09ac\u0003\u0002\u0002',
+  '\u0002\u09ac\u09ae\u0005\u0164\u00b3\u0002\u09ad\u09aa\u0003\u0002\u0002',
+  '\u0002\u09ae\u09af\u0003\u0002\u0002\u0002\u09af\u09ad\u0003\u0002\u0002',
+  '\u0002\u09af\u09b0\u0003\u0002\u0002\u0002\u09b0\u09b2\u0003\u0002\u0002',
+  '\u0002\u09b1\u099b\u0003\u0002\u0002\u0002\u09b1\u09a4\u0003\u0002\u0002',
+  '\u0002\u09b2\u09bb\u0003\u0002\u0002\u0002\u09b3\u09b5\u0007\u0099\u0002',
+  '\u0002\u09b4\u09b3\u0003\u0002\u0002\u0002\u09b4\u09b5\u0003\u0002\u0002',
+  '\u0002\u09b5\u09b6\u0003\u0002\u0002\u0002\u09b6\u09b8\u0007\u007f\u0002',
+  '\u0002\u09b7\u09b9\u0007\u0099\u0002\u0002\u09b8\u09b7\u0003\u0002\u0002',
+  '\u0002\u09b8\u09b9\u0003\u0002\u0002\u0002\u09b9\u09ba\u0003\u0002\u0002',
+  '\u0002\u09ba\u09bc\u0005\u0102\u0082\u0002\u09bb\u09b4\u0003\u0002\u0002',
+  '\u0002\u09bb\u09bc\u0003\u0002\u0002\u0002\u09bc\u09be\u0003\u0002\u0002',
+  '\u0002\u09bd\u09bf\u0007\u0099\u0002\u0002\u09be\u09bd\u0003\u0002\u0002',
+  '\u0002\u09be\u09bf\u0003\u0002\u0002\u0002\u09bf\u09c0\u0003\u0002\u0002',
+  '\u0002\u09c0\u09c1\u0007\u0080\u0002\u0002\u09c1\u0163\u0003\u0002\u0002',
+  '\u0002\u09c2\u09c4\u0007\u0081\u0002\u0002\u09c3\u09c5\u0007\u0099\u0002',
+  '\u0002\u09c4\u09c3\u0003\u0002\u0002\u0002\u09c4\u09c5\u0003\u0002\u0002',
+  '\u0002\u09c5\u09c6\u0003\u0002\u0002\u0002\u09c6\u09c8\u0005\u0102\u0082',
+  '\u0002\u09c7\u09c9\u0007\u0099\u0002\u0002\u09c8\u09c7\u0003\u0002\u0002',
+  '\u0002\u09c8\u09c9\u0003\u0002\u0002\u0002\u09c9\u09ca\u0003\u0002\u0002',
+  '\u0002\u09ca\u09cc\u0007\u0082\u0002\u0002\u09cb\u09cd\u0007\u0099\u0002',
+  '\u0002\u09cc\u09cb\u0003\u0002\u0002\u0002\u09cc\u09cd\u0003\u0002\u0002',
+  '\u0002\u09cd\u09ce\u0003\u0002\u0002\u0002\u09ce\u09cf\u0005\u0102\u0082',
+  '\u0002\u09cf\u0165\u0003\u0002\u0002\u0002\u09d0\u09d1\u0005\u0194\u00cb',
+  '\u0002\u09d1\u0167\u0003\u0002\u0002\u0002\u09d2\u09d5\u0005\u018a\u00c6',
+  '\u0002\u09d3\u09d5\u0005\u0188\u00c5\u0002\u09d4\u09d2\u0003\u0002\u0002',
+  '\u0002\u09d4\u09d3\u0003\u0002\u0002\u0002\u09d5\u0169\u0003\u0002\u0002',
+  '\u0002\u09d6\u09d8\u0007\u0010\u0002\u0002\u09d7\u09d9\u0007\u0099\u0002',
+  '\u0002\u09d8\u09d7\u0003\u0002\u0002\u0002\u09d8\u09d9\u0003\u0002\u0002',
+  '\u0002\u09d9\u09eb\u0003\u0002\u0002\u0002\u09da\u09dc\u0005\u0170\u00b9',
+  '\u0002\u09db\u09dd\u0007\u0099\u0002\u0002\u09dc\u09db\u0003\u0002\u0002',
+  '\u0002\u09dc\u09dd\u0003\u0002\u0002\u0002\u09dd\u09e8\u0003\u0002\u0002',
+  '\u0002\u09de\u09e0\u0007\u0011\u0002\u0002\u09df\u09e1\u0007\u0099\u0002',
+  '\u0002\u09e0\u09df\u0003\u0002\u0002\u0002\u09e0\u09e1\u0003\u0002\u0002',
+  '\u0002\u09e1\u09e2\u0003\u0002\u0002\u0002\u09e2\u09e4\u0005\u0170\u00b9',
+  '\u0002\u09e3\u09e5\u0007\u0099\u0002\u0002\u09e4\u09e3\u0003\u0002\u0002',
+  '\u0002\u09e4\u09e5\u0003\u0002\u0002\u0002\u09e5\u09e7\u0003\u0002\u0002',
+  '\u0002\u09e6\u09de\u0003\u0002\u0002\u0002\u09e7\u09ea\u0003\u0002\u0002',
+  '\u0002\u09e8\u09e6\u0003\u0002\u0002\u0002\u09e8\u09e9\u0003\u0002\u0002',
+  '\u0002\u09e9\u09ec\u0003\u0002\u0002\u0002\u09ea\u09e8\u0003\u0002\u0002',
+  '\u0002\u09eb\u09da\u0003\u0002\u0002\u0002\u09eb\u09ec\u0003\u0002\u0002',
+  '\u0002\u09ec\u09ed\u0003\u0002\u0002\u0002\u09ed\u09ee\u0007\u0012\u0002',
+  '\u0002\u09ee\u016b\u0003\u0002\u0002\u0002\u09ef\u09f1\u0005\u0166\u00b4',
+  '\u0002\u09f0\u09f2\u0007\u0099\u0002\u0002\u09f1\u09f0\u0003\u0002\u0002',
+  '\u0002\u09f1\u09f2\u0003\u0002\u0002\u0002\u09f2\u09f3\u0003\u0002\u0002',
+  '\u0002\u09f3\u09f5\u0007\u0010\u0002\u0002\u09f4\u09f6\u0007\u0099\u0002',
+  '\u0002\u09f5\u09f4\u0003\u0002\u0002\u0002\u09f5\u09f6\u0003\u0002\u0002',
+  '\u0002\u09f6\u09f8\u0003\u0002\u0002\u0002\u09f7\u09f9\u0005\u016e\u00b8',
+  '\u0002\u09f8\u09f7\u0003\u0002\u0002\u0002\u09f8\u09f9\u0003\u0002\u0002',
+  '\u0002\u09f9\u0a04\u0003\u0002\u0002\u0002\u09fa\u09fc\u0007\u0099\u0002',
+  '\u0002\u09fb\u09fa\u0003\u0002\u0002\u0002\u09fb\u09fc\u0003\u0002\u0002',
+  '\u0002\u09fc\u09fd\u0003\u0002\u0002\u0002\u09fd\u09ff\u0007\u0011\u0002',
+  '\u0002\u09fe\u0a00\u0007\u0099\u0002\u0002\u09ff\u09fe\u0003\u0002\u0002',
+  '\u0002\u09ff\u0a00\u0003\u0002\u0002\u0002\u0a00\u0a01\u0003\u0002\u0002',
+  '\u0002\u0a01\u0a03\u0005\u016e\u00b8\u0002\u0a02\u09fb\u0003\u0002\u0002',
+  '\u0002\u0a03\u0a06\u0003\u0002\u0002\u0002\u0a04\u0a02\u0003\u0002\u0002',
+  '\u0002\u0a04\u0a05\u0003\u0002\u0002\u0002\u0a05\u0a08\u0003\u0002\u0002',
+  '\u0002\u0a06\u0a04\u0003\u0002\u0002\u0002\u0a07\u0a09\u0007\u0099\u0002',
+  '\u0002\u0a08\u0a07\u0003\u0002\u0002\u0002\u0a08\u0a09\u0003\u0002\u0002',
+  '\u0002\u0a09\u0a0a\u0003\u0002\u0002\u0002\u0a0a\u0a0b\u0007\u0012\u0002',
+  '\u0002\u0a0b\u016d\u0003\u0002\u0002\u0002\u0a0c\u0a11\u0005\u0170\u00b9',
+  '\u0002\u0a0d\u0a11\u0005\u0172\u00ba\u0002\u0a0e\u0a11\u0005\u0174\u00bb',
+  '\u0002\u0a0f\u0a11\u0005\u0176\u00bc\u0002\u0a10\u0a0c\u0003\u0002\u0002',
+  '\u0002\u0a10\u0a0d\u0003\u0002\u0002\u0002\u0a10\u0a0e\u0003\u0002\u0002',
+  '\u0002\u0a10\u0a0f\u0003\u0002\u0002\u0002\u0a11\u016f\u0003\u0002\u0002',
+  '\u0002\u0a12\u0a14\u0005\u0186\u00c4\u0002\u0a13\u0a15\u0007\u0099\u0002',
+  '\u0002\u0a14\u0a13\u0003\u0002\u0002\u0002\u0a14\u0a15\u0003\u0002\u0002',
+  '\u0002\u0a15\u0a16\u0003\u0002\u0002\u0002\u0a16\u0a18\u0007\u0004\u0002',
+  '\u0002\u0a17\u0a19\u0007\u0099\u0002\u0002\u0a18\u0a17\u0003\u0002\u0002',
+  '\u0002\u0a18\u0a19\u0003\u0002\u0002\u0002\u0a19\u0a1a\u0003\u0002\u0002',
+  '\u0002\u0a1a\u0a1b\u0005\u0102\u0082\u0002\u0a1b\u0171\u0003\u0002\u0002',
+  '\u0002\u0a1c\u0a1d\u0007\t\u0002\u0002\u0a1d\u0a1e\u0005\u0166\u00b4',
+  '\u0002\u0a1e\u0173\u0003\u0002\u0002\u0002\u0a1f\u0a20\u0005\u0166\u00b4',
+  '\u0002\u0a20\u0175\u0003\u0002\u0002\u0002\u0a21\u0a22\u0007\t\u0002',
+  '\u0002\u0a22\u0a23\u0007\u0019\u0002\u0002\u0a23\u0177\u0003\u0002\u0002',
+  '\u0002\u0a24\u0a27\u0005\u017a\u00be\u0002\u0a25\u0a27\u0005\u017c\u00bf',
+  '\u0002\u0a26\u0a24\u0003\u0002\u0002\u0002\u0a26\u0a25\u0003\u0002\u0002',
+  '\u0002\u0a27\u0179\u0003\u0002\u0002\u0002\u0a28\u0a2a\u0007\u0010\u0002',
+  '\u0002\u0a29\u0a2b\u0007\u0099\u0002\u0002\u0a2a\u0a29\u0003\u0002\u0002',
+  '\u0002\u0a2a\u0a2b\u0003\u0002\u0002\u0002\u0a2b\u0a2c\u0003\u0002\u0002',
+  '\u0002\u0a2c\u0a2e\u0005\u017e\u00c0\u0002\u0a2d\u0a2f\u0007\u0099\u0002',
+  '\u0002\u0a2e\u0a2d\u0003\u0002\u0002\u0002\u0a2e\u0a2f\u0003\u0002\u0002',
+  '\u0002\u0a2f\u0a30\u0003\u0002\u0002\u0002\u0a30\u0a31\u0007\u0012\u0002',
+  '\u0002\u0a31\u017b\u0003\u0002\u0002\u0002\u0a32\u0a33\u0007$\u0002',
+  '\u0002\u0a33\u0a34\u0005\u017e\u00c0\u0002\u0a34\u017d\u0003\u0002\u0002',
+  '\u0002\u0a35\u0a38\u0005\u0194\u00cb\u0002\u0a36\u0a38\u0007\u008a\u0002',
+  '\u0002\u0a37\u0a35\u0003\u0002\u0002\u0002\u0a37\u0a36\u0003\u0002\u0002',
+  '\u0002\u0a38\u017f\u0003\u0002\u0002\u0002\u0a39\u0a44\u0005\u0182\u00c2',
+  '\u0002\u0a3a\u0a3c\u0007\u0099\u0002\u0002\u0a3b\u0a3a\u0003\u0002\u0002',
+  '\u0002\u0a3b\u0a3c\u0003\u0002\u0002\u0002\u0a3c\u0a3d\u0003\u0002\u0002',
+  '\u0002\u0a3d\u0a3f\u0007\u0011\u0002\u0002\u0a3e\u0a40\u0007\u0099\u0002',
+  '\u0002\u0a3f\u0a3e\u0003\u0002\u0002\u0002\u0a3f\u0a40\u0003\u0002\u0002',
+  '\u0002\u0a40\u0a41\u0003\u0002\u0002\u0002\u0a41\u0a43\u0005\u0182\u00c2',
+  '\u0002\u0a42\u0a3b\u0003\u0002\u0002\u0002\u0a43\u0a46\u0003\u0002\u0002',
+  '\u0002\u0a44\u0a42\u0003\u0002\u0002\u0002\u0a44\u0a45\u0003\u0002\u0002',
+  '\u0002\u0a45\u0181\u0003\u0002\u0002\u0002\u0a46\u0a44\u0003\u0002\u0002',
+  '\u0002\u0a47\u0a4c\u0005\u0140\u00a1\u0002\u0a48\u0a4a\u0007\u0099\u0002',
+  '\u0002\u0a49\u0a48\u0003\u0002\u0002\u0002\u0a49\u0a4a\u0003\u0002\u0002',
+  '\u0002\u0a4a\u0a4b\u0003\u0002\u0002\u0002\u0a4b\u0a4d\u0005\u0160\u00b1',
+  '\u0002\u0a4c\u0a49\u0003\u0002\u0002\u0002\u0a4d\u0a4e\u0003\u0002\u0002',
+  '\u0002\u0a4e\u0a4c\u0003\u0002\u0002\u0002\u0a4e\u0a4f\u0003\u0002\u0002',
+  '\u0002\u0a4f\u0183\u0003\u0002\u0002\u0002\u0a50\u0a5b\u0005\u0186\u00c4',
+  '\u0002\u0a51\u0a53\u0007\u0099\u0002\u0002\u0a52\u0a51\u0003\u0002\u0002',
+  '\u0002\u0a52\u0a53\u0003\u0002\u0002\u0002\u0a53\u0a54\u0003\u0002\u0002',
+  '\u0002\u0a54\u0a56\u0007\u0011\u0002\u0002\u0a55\u0a57\u0007\u0099\u0002',
+  '\u0002\u0a56\u0a55\u0003\u0002\u0002\u0002\u0a56\u0a57\u0003\u0002\u0002',
+  '\u0002\u0a57\u0a58\u0003\u0002\u0002\u0002\u0a58\u0a5a\u0005\u0186\u00c4',
+  '\u0002\u0a59\u0a52\u0003\u0002\u0002\u0002\u0a5a\u0a5d\u0003\u0002\u0002',
+  '\u0002\u0a5b\u0a59\u0003\u0002\u0002\u0002\u0a5b\u0a5c\u0003\u0002\u0002',
+  '\u0002\u0a5c\u0185\u0003\u0002\u0002\u0002\u0a5d\u0a5b\u0003\u0002\u0002',
+  '\u0002\u0a5e\u0a5f\u0005\u0194\u00cb\u0002\u0a5f\u0187\u0003\u0002\u0002',
+  '\u0002\u0a60\u0a61\t\b\u0002\u0002\u0a61\u0189\u0003\u0002\u0002\u0002',
+  '\u0a62\u0a63\t\t\u0002\u0002\u0a63\u018b\u0003\u0002\u0002\u0002\u0a64',
+  '\u0a65\u0005\u0194\u00cb\u0002\u0a65\u0a66\u0007\t\u0002\u0002\u0a66',
+  '\u0a68\u0003\u0002\u0002\u0002\u0a67\u0a64\u0003\u0002\u0002\u0002\u0a68',
+  '\u0a6b\u0003\u0002\u0002\u0002\u0a69\u0a67\u0003\u0002\u0002\u0002\u0a69',
+  '\u0a6a\u0003\u0002\u0002\u0002\u0a6a\u018d\u0003\u0002\u0002\u0002\u0a6b',
+  '\u0a69\u0003\u0002\u0002\u0002\u0a6c\u0a6d\t\n\u0002\u0002\u0a6d\u018f',
+  '\u0003\u0002\u0002\u0002\u0a6e\u0a6f\t\u000b\u0002\u0002\u0a6f\u0191',
+  '\u0003\u0002\u0002\u0002\u0a70\u0a71\t\f\u0002\u0002\u0a71\u0193\u0003',
+  '\u0002\u0002\u0002\u0a72\u0a77\u0005\u0196\u00cc\u0002\u0a73\u0a77\u0007',
+  '\u0095\u0002\u0002\u0a74\u0a77\u0007\u0098\u0002\u0002\u0a75\u0a77\u0007',
+  '\u008c\u0002\u0002\u0a76\u0a72\u0003\u0002\u0002\u0002\u0a76\u0a73\u0003',
+  '\u0002\u0002\u0002\u0a76\u0a74\u0003\u0002\u0002\u0002\u0a76\u0a75\u0003',
+  '\u0002\u0002\u0002\u0a77\u0195\u0003\u0002\u0002\u0002\u0a78\u0a79\t',
+  '\r\u0002\u0002\u0a79\u0197\u0003\u0002\u0002\u0002\u01a6\u019d\u01a1',
+  '\u01a6\u01aa\u01ad\u01b2\u01ba\u01c2\u01cf\u01d3\u01d7\u01e0\u01e5\u01e9',
+  '\u01ec\u01ef\u01f4\u01f8\u01ff\u0211\u0228\u0230\u0232\u0236\u023b\u0241',
+  '\u0247\u024b\u024f\u0253\u0257\u025e\u0261\u0265\u0269\u026f\u0273\u0277',
+  '\u027b\u027f\u0286\u0289\u0291\u029a\u029f\u02a3\u02a6\u02ad\u02b5\u02b9',
+  '\u02bf\u02c4\u02ca\u02d5\u02d9\u02df\u02e3\u02e7\u02ec\u02f1\u02f7\u02fc',
+  '\u0306\u030a\u030f\u0316\u031b\u031e\u032e\u033a\u0368\u036c\u0370\u0374',
+  '\u037c\u0380\u0385\u0389\u0397\u039b\u03a0\u03a4\u03aa\u03ae\u03bc\u03c3',
+  '\u03c9\u03d3\u03d7\u03dd\u03e5\u03f0\u03f6\u0402\u0408\u0414\u0418\u0422',
+  '\u042f\u0433\u0437\u043d\u0441\u0444\u0448\u0452\u0459\u0466\u046a\u0472',
+  '\u0478\u047c\u0480\u0485\u048a\u048e\u0494\u0498\u049e\u04a2\u04a8\u04ac',
+  '\u04b0\u04b4\u04b8\u04bc\u04c1\u04c8\u04cc\u04d1\u04d8\u04dc\u04e0\u04e8',
+  '\u04ef\u04f2\u04f8\u04fb\u0500\u0503\u0507\u050a\u050d\u0514\u0518\u051c',
+  '\u0520\u0524\u0529\u052e\u0532\u0537\u053c\u053f\u0541\u054a\u0550\u0553',
+  '\u0557\u055a\u0561\u0564\u0567\u056b\u0570\u0574\u057c\u0580\u0585\u058a',
+  '\u058e\u05a0\u05a4\u05a9\u05b6\u05ba\u05bc\u05bf\u05c8\u05cc\u05d0\u05dc',
+  '\u05e0\u05e5\u05ef\u05f5\u05f9\u05fe\u0602\u0606\u060a\u0610\u0614\u0619',
+  '\u061f\u0628\u0631\u0639\u063f\u0643\u0648\u0651\u0655\u065a\u065f\u0663',
+  '\u0668\u066c\u0670\u0675\u067c\u0680\u0684\u0686\u068a\u068c\u0690\u0692',
+  '\u0698\u069e\u06a1\u06a4\u06aa\u06af\u06b3\u06b8\u06bc\u06c0\u06c2\u06c6',
+  '\u06c8\u06cb\u06cf\u06d1\u06d7\u06db\u06e1\u06e7\u06ee\u06f4\u06f9\u0701',
+  '\u0705\u0707\u070b\u070f\u0711\u0713\u0722\u072c\u0736\u073b\u073f\u0746',
+  '\u074b\u0750\u0754\u0758\u075c\u075f\u0761\u0766\u076a\u076e\u0772\u0776',
+  '\u077a\u077d\u077f\u0784\u0788\u078d\u0792\u0796\u079d\u07a4\u07a8\u07ac',
+  '\u07b0\u07bf\u07c2\u07cf\u07d1\u07d6\u07da\u07de\u07e3\u07e7\u07eb\u07f3',
+  '\u07f7\u07fb\u0803\u0807\u080b\u0813\u0817\u081b\u0823\u0827\u082b\u0833',
+  '\u0837\u083b\u0843\u0847\u084b\u084f\u0852\u0855\u085d\u0861\u0865\u0869',
+  '\u086d\u0871\u0875\u0879\u087d\u0885\u0889\u088d\u0893\u0897\u089b\u089f',
+  '\u08aa\u08ae\u08b2\u08c4\u08cd\u08d5\u08d9\u08dd\u08e1\u08e5\u08e8\u08ee',
+  '\u08f3\u08f8\u08fd\u0902\u0907\u090c\u090f\u0913\u0917\u091d\u0922\u0926',
+  '\u0929\u0933\u0937\u093b\u093d\u0941\u0945\u0949\u094d\u0950\u095d\u0961',
+  '\u0965\u0968\u096b\u0971\u0975\u0979\u097b\u097f\u0983\u0987\u0989\u098d',
+  '\u0991\u0997\u099d\u09a2\u09a6\u09aa\u09af\u09b1\u09b4\u09b8\u09bb\u09be',
+  '\u09c4\u09c8\u09cc\u09d4\u09d8\u09dc\u09e0\u09e4\u09e8\u09eb\u09f1\u09f5',
+  '\u09f8\u09fb\u09ff\u0a04\u0a08\u0a10\u0a14\u0a18\u0a26\u0a2a\u0a2e\u0a37',
+  '\u0a3b\u0a3f\u0a44\u0a49\u0a4e\u0a52\u0a56\u0a5b\u0a69\u0a76'
+].join('')
+
+var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN)
+
+var decisionsToDFA = atn.decisionToState.map(function(ds, index) {
+  return new antlr4.dfa.DFA(ds, index)
+})
+
+var sharedContextCache = new antlr4.PredictionContextCache()
+
+var literalNames = [
+  null,
+  "';'",
+  "':'",
+  "'-'",
+  "'=>'",
+  "'://'",
+  "'/'",
+  "'.'",
+  "'@'",
+  "'#'",
+  "'?'",
+  "'&'",
+  "'='",
+  "'+'",
+  "'{'",
+  "','",
+  "'}'",
+  "'['",
+  "']'",
+  "'('",
+  "')'",
+  "'+='",
+  "'|'",
+  "'*'",
+  "'..'",
+  "'%'",
+  "'^'",
+  "'=~'",
+  "'<>'",
+  "'!='",
+  "'<'",
+  "'>'",
+  "'<='",
+  "'>='",
+  "'$'",
+  "'\u27E8'",
+  "'\u3008'",
+  "'\uFE64'",
+  "'\uFF1C'",
+  "'\u27E9'",
+  "'\u3009'",
+  "'\uFE65'",
+  "'\uFF1E'",
+  "'\u00AD'",
+  "'\u2010'",
+  "'\u2011'",
+  "'\u2012'",
+  "'\u2013'",
+  "'\u2014'",
+  "'\u2015'",
+  "'\u2212'",
+  "'\uFE58'",
+  "'\uFE63'",
+  "'\uFF0D'",
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  "'0'"
+]
+
+var symbolicNames = [
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  'CYPHER',
+  'EXPLAIN',
+  'PROFILE',
+  'USING',
+  'PERIODIC',
+  'COMMIT',
+  'UNION',
+  'ALL',
+  'CREATE',
+  'DROP',
+  'INDEX',
+  'ON',
+  'CONSTRAINT',
+  'ASSERT',
+  'IS',
+  'UNIQUE',
+  'EXISTS',
+  'LOAD',
+  'CSV',
+  'WITH',
+  'HEADERS',
+  'FROM',
+  'AS',
+  'FIELDTERMINATOR',
+  'OPTIONAL',
+  'MATCH',
+  'UNWIND',
+  'MERGE',
+  'SET',
+  'DETACH',
+  'DELETE',
+  'REMOVE',
+  'FOREACH',
+  'IN',
+  'DISTINCT',
+  'RETURN',
+  'ORDER',
+  'BY',
+  'L_SKIP',
+  'LIMIT',
+  'ASCENDING',
+  'ASC',
+  'DESCENDING',
+  'DESC',
+  'JOIN',
+  'SCAN',
+  'START',
+  'NODE',
+  'RELATIONSHIP',
+  'REL',
+  'WHERE',
+  'SHORTESTPATH',
+  'ALLSHORTESTPATHS',
+  'OR',
+  'XOR',
+  'AND',
+  'NOT',
+  'STARTS',
+  'ENDS',
+  'CONTAINS',
+  'NULL',
+  'COUNT',
+  'FILTER',
+  'EXTRACT',
+  'ANY',
+  'NONE',
+  'SINGLE',
+  'TRUE',
+  'FALSE',
+  'REDUCE',
+  'CASE',
+  'ELSE',
+  'END',
+  'WHEN',
+  'THEN',
+  'CALL',
+  'YIELD',
+  'KEY',
+  'StringLiteral',
+  'UrlHex',
+  'EscapedChar',
+  'HexInteger',
+  'DecimalInteger',
+  'OctalInteger',
+  'HexLetter',
+  'HexDigit',
+  'Digit',
+  'NonZeroDigit',
+  'NonZeroOctDigit',
+  'OctDigit',
+  'ZeroDigit',
+  'ExponentDecimalReal',
+  'RegularDecimalReal',
+  'UnescapedSymbolicName',
+  'IdentifierStart',
+  'IdentifierPart',
+  'EscapedSymbolicName',
+  'SP',
+  'WHITESPACE',
+  'Comment',
+  'ERROR_TOKEN'
+]
+
+var ruleNames = [
+  'cypher',
+  'cypherPart',
+  'cypherConsoleCommand',
+  'cypherConsoleCommandName',
+  'cypherConsoleCommandParameters',
+  'cypherConsoleCommandParameter',
+  'arrowExpression',
+  'url',
+  'uri',
+  'scheme',
+  'host',
+  'hostname',
+  'hostnumber',
+  'port',
+  'path',
+  'user',
+  'login',
+  'password',
+  'frag',
+  'urlQuery',
+  'search',
+  'searchparameter',
+  'string',
+  'urlDigits',
+  'json',
+  'obj',
+  'pair',
+  'array',
+  'value',
+  'keyValueLiteral',
+  'commandPath',
+  'subCommand',
+  'cypherQuery',
+  'queryOptions',
+  'anyCypherOption',
+  'cypherOption',
+  'versionNumber',
+  'explain',
+  'profile',
+  'configurationOption',
+  'statement',
+  'query',
+  'regularQuery',
+  'bulkImportQuery',
+  'singleQuery',
+  'periodicCommitHint',
+  'loadCSVQuery',
+  'union',
+  'clause',
+  'command',
+  'createUniqueConstraint',
+  'createNodeKeyConstraint',
+  'createNodePropertyExistenceConstraint',
+  'createRelationshipPropertyExistenceConstraint',
+  'createIndex',
+  'dropUniqueConstraint',
+  'dropNodeKeyConstraint',
+  'dropNodePropertyExistenceConstraint',
+  'dropRelationshipPropertyExistenceConstraint',
+  'dropIndex',
+  'index',
+  'uniqueConstraint',
+  'nodeKeyConstraint',
+  'nodePropertyExistenceConstraint',
+  'relationshipPropertyExistenceConstraint',
+  'relationshipPatternSyntax',
+  'loadCSVClause',
+  'matchClause',
+  'unwindClause',
+  'mergeClause',
+  'mergeAction',
+  'createClause',
+  'createUniqueClause',
+  'setClause',
+  'setItem',
+  'deleteClause',
+  'removeClause',
+  'removeItem',
+  'foreachClause',
+  'withClause',
+  'returnClause',
+  'returnBody',
+  'returnItems',
+  'returnItem',
+  'call',
+  'procedureInvocation',
+  'procedureInvocationBody',
+  'procedureArguments',
+  'procedureResults',
+  'procedureResult',
+  'aliasedProcedureResult',
+  'simpleProcedureResult',
+  'procedureOutput',
+  'order',
+  'skip',
+  'limit',
+  'sortItem',
+  'hint',
+  'startClause',
+  'startPoint',
+  'lookup',
+  'nodeLookup',
+  'relationshipLookup',
+  'identifiedIndexLookup',
+  'indexQuery',
+  'idLookup',
+  'literalIds',
+  'where',
+  'pattern',
+  'patternPart',
+  'anonymousPatternPart',
+  'patternElement',
+  'nodePattern',
+  'patternElementChain',
+  'relationshipPattern',
+  'relationshipPatternStart',
+  'relationshipPatternEnd',
+  'relationshipDetail',
+  'properties',
+  'relType',
+  'relationshipTypes',
+  'relationshipType',
+  'relationshipTypeOptionalColon',
+  'nodeLabels',
+  'nodeLabel',
+  'rangeLiteral',
+  'labelName',
+  'relTypeName',
+  'expression',
+  'orExpression',
+  'xorExpression',
+  'andExpression',
+  'notExpression',
+  'comparisonExpression',
+  'addOrSubtractExpression',
+  'multiplyDivideModuloExpression',
+  'powerOfExpression',
+  'unaryAddOrSubtractExpression',
+  'stringListNullOperatorExpression',
+  'propertyOrLabelsExpression',
+  'filterFunction',
+  'filterFunctionName',
+  'existsFunction',
+  'existsFunctionName',
+  'allFunction',
+  'allFunctionName',
+  'anyFunction',
+  'anyFunctionName',
+  'noneFunction',
+  'noneFunctionName',
+  'singleFunction',
+  'singleFunctionName',
+  'extractFunction',
+  'extractFunctionName',
+  'reduceFunction',
+  'reduceFunctionName',
+  'shortestPathPatternFunction',
+  'shortestPathFunctionName',
+  'allShortestPathFunctionName',
+  'atom',
+  'literal',
+  'stringLiteral',
+  'booleanLiteral',
+  'listLiteral',
+  'partialComparisonExpression',
+  'parenthesizedExpression',
+  'relationshipsPattern',
+  'filterExpression',
+  'idInColl',
+  'functionInvocation',
+  'functionInvocationBody',
+  'functionName',
+  'procedureName',
+  'listComprehension',
+  'patternComprehension',
+  'propertyLookup',
+  'caseExpression',
+  'caseAlternatives',
+  'variable',
+  'numberLiteral',
+  'mapLiteral',
+  'mapProjection',
+  'mapProjectionVariants',
+  'literalEntry',
+  'propertySelector',
+  'variableSelector',
+  'allPropertiesSelector',
+  'parameter',
+  'legacyParameter',
+  'newParameter',
+  'parameterName',
+  'propertyExpressions',
+  'propertyExpression',
+  'propertyKeys',
+  'propertyKeyName',
+  'integerLiteral',
+  'doubleLiteral',
+  'namespace',
+  'leftArrowHead',
+  'rightArrowHead',
+  'dash',
+  'symbolicName',
+  'keyword'
+]
+
+function CypherParser(input) {
+  antlr4.Parser.call(this, input)
+  this._interp = new antlr4.atn.ParserATNSimulator(
+    this,
+    atn,
+    decisionsToDFA,
+    sharedContextCache
+  )
+  this.ruleNames = ruleNames
+  this.literalNames = literalNames
+  this.symbolicNames = symbolicNames
+  return this
+}
+
+CypherParser.prototype = Object.create(antlr4.Parser.prototype)
+CypherParser.prototype.constructor = CypherParser
+
+Object.defineProperty(CypherParser.prototype, 'atn', {
+  get: function() {
+    return atn
+  }
+})
+
+CypherParser.EOF = antlr4.Token.EOF
+CypherParser.T__0 = 1
+CypherParser.T__1 = 2
+CypherParser.T__2 = 3
+CypherParser.T__3 = 4
+CypherParser.T__4 = 5
+CypherParser.T__5 = 6
+CypherParser.T__6 = 7
+CypherParser.T__7 = 8
+CypherParser.T__8 = 9
+CypherParser.T__9 = 10
+CypherParser.T__10 = 11
+CypherParser.T__11 = 12
+CypherParser.T__12 = 13
+CypherParser.T__13 = 14
+CypherParser.T__14 = 15
+CypherParser.T__15 = 16
+CypherParser.T__16 = 17
+CypherParser.T__17 = 18
+CypherParser.T__18 = 19
+CypherParser.T__19 = 20
+CypherParser.T__20 = 21
+CypherParser.T__21 = 22
+CypherParser.T__22 = 23
+CypherParser.T__23 = 24
+CypherParser.T__24 = 25
+CypherParser.T__25 = 26
+CypherParser.T__26 = 27
+CypherParser.T__27 = 28
+CypherParser.T__28 = 29
+CypherParser.T__29 = 30
+CypherParser.T__30 = 31
+CypherParser.T__31 = 32
+CypherParser.T__32 = 33
+CypherParser.T__33 = 34
+CypherParser.T__34 = 35
+CypherParser.T__35 = 36
+CypherParser.T__36 = 37
+CypherParser.T__37 = 38
+CypherParser.T__38 = 39
+CypherParser.T__39 = 40
+CypherParser.T__40 = 41
+CypherParser.T__41 = 42
+CypherParser.T__42 = 43
+CypherParser.T__43 = 44
+CypherParser.T__44 = 45
+CypherParser.T__45 = 46
+CypherParser.T__46 = 47
+CypherParser.T__47 = 48
+CypherParser.T__48 = 49
+CypherParser.T__49 = 50
+CypherParser.T__50 = 51
+CypherParser.T__51 = 52
+CypherParser.T__52 = 53
+CypherParser.CYPHER = 54
+CypherParser.EXPLAIN = 55
+CypherParser.PROFILE = 56
+CypherParser.USING = 57
+CypherParser.PERIODIC = 58
+CypherParser.COMMIT = 59
+CypherParser.UNION = 60
+CypherParser.ALL = 61
+CypherParser.CREATE = 62
+CypherParser.DROP = 63
+CypherParser.INDEX = 64
+CypherParser.ON = 65
+CypherParser.CONSTRAINT = 66
+CypherParser.ASSERT = 67
+CypherParser.IS = 68
+CypherParser.UNIQUE = 69
+CypherParser.EXISTS = 70
+CypherParser.LOAD = 71
+CypherParser.CSV = 72
+CypherParser.WITH = 73
+CypherParser.HEADERS = 74
+CypherParser.FROM = 75
+CypherParser.AS = 76
+CypherParser.FIELDTERMINATOR = 77
+CypherParser.OPTIONAL = 78
+CypherParser.MATCH = 79
+CypherParser.UNWIND = 80
+CypherParser.MERGE = 81
+CypherParser.SET = 82
+CypherParser.DETACH = 83
+CypherParser.DELETE = 84
+CypherParser.REMOVE = 85
+CypherParser.FOREACH = 86
+CypherParser.IN = 87
+CypherParser.DISTINCT = 88
+CypherParser.RETURN = 89
+CypherParser.ORDER = 90
+CypherParser.BY = 91
+CypherParser.L_SKIP = 92
+CypherParser.LIMIT = 93
+CypherParser.ASCENDING = 94
+CypherParser.ASC = 95
+CypherParser.DESCENDING = 96
+CypherParser.DESC = 97
+CypherParser.JOIN = 98
+CypherParser.SCAN = 99
+CypherParser.START = 100
+CypherParser.NODE = 101
+CypherParser.RELATIONSHIP = 102
+CypherParser.REL = 103
+CypherParser.WHERE = 104
+CypherParser.SHORTESTPATH = 105
+CypherParser.ALLSHORTESTPATHS = 106
+CypherParser.OR = 107
+CypherParser.XOR = 108
+CypherParser.AND = 109
+CypherParser.NOT = 110
+CypherParser.STARTS = 111
+CypherParser.ENDS = 112
+CypherParser.CONTAINS = 113
+CypherParser.NULL = 114
+CypherParser.COUNT = 115
+CypherParser.FILTER = 116
+CypherParser.EXTRACT = 117
+CypherParser.ANY = 118
+CypherParser.NONE = 119
+CypherParser.SINGLE = 120
+CypherParser.TRUE = 121
+CypherParser.FALSE = 122
+CypherParser.REDUCE = 123
+CypherParser.CASE = 124
+CypherParser.ELSE = 125
+CypherParser.END = 126
+CypherParser.WHEN = 127
+CypherParser.THEN = 128
+CypherParser.CALL = 129
+CypherParser.YIELD = 130
+CypherParser.KEY = 131
+CypherParser.StringLiteral = 132
+CypherParser.UrlHex = 133
+CypherParser.EscapedChar = 134
+CypherParser.HexInteger = 135
+CypherParser.DecimalInteger = 136
+CypherParser.OctalInteger = 137
+CypherParser.HexLetter = 138
+CypherParser.HexDigit = 139
+CypherParser.Digit = 140
+CypherParser.NonZeroDigit = 141
+CypherParser.NonZeroOctDigit = 142
+CypherParser.OctDigit = 143
+CypherParser.ZeroDigit = 144
+CypherParser.ExponentDecimalReal = 145
+CypherParser.RegularDecimalReal = 146
+CypherParser.UnescapedSymbolicName = 147
+CypherParser.IdentifierStart = 148
+CypherParser.IdentifierPart = 149
+CypherParser.EscapedSymbolicName = 150
+CypherParser.SP = 151
+CypherParser.WHITESPACE = 152
+CypherParser.Comment = 153
+CypherParser.ERROR_TOKEN = 154
+
+CypherParser.RULE_cypher = 0
+CypherParser.RULE_cypherPart = 1
+CypherParser.RULE_cypherConsoleCommand = 2
+CypherParser.RULE_cypherConsoleCommandName = 3
+CypherParser.RULE_cypherConsoleCommandParameters = 4
+CypherParser.RULE_cypherConsoleCommandParameter = 5
+CypherParser.RULE_arrowExpression = 6
+CypherParser.RULE_url = 7
+CypherParser.RULE_uri = 8
+CypherParser.RULE_scheme = 9
+CypherParser.RULE_host = 10
+CypherParser.RULE_hostname = 11
+CypherParser.RULE_hostnumber = 12
+CypherParser.RULE_port = 13
+CypherParser.RULE_path = 14
+CypherParser.RULE_user = 15
+CypherParser.RULE_login = 16
+CypherParser.RULE_password = 17
+CypherParser.RULE_frag = 18
+CypherParser.RULE_urlQuery = 19
+CypherParser.RULE_search = 20
+CypherParser.RULE_searchparameter = 21
+CypherParser.RULE_string = 22
+CypherParser.RULE_urlDigits = 23
+CypherParser.RULE_json = 24
+CypherParser.RULE_obj = 25
+CypherParser.RULE_pair = 26
+CypherParser.RULE_array = 27
+CypherParser.RULE_value = 28
+CypherParser.RULE_keyValueLiteral = 29
+CypherParser.RULE_commandPath = 30
+CypherParser.RULE_subCommand = 31
+CypherParser.RULE_cypherQuery = 32
+CypherParser.RULE_queryOptions = 33
+CypherParser.RULE_anyCypherOption = 34
+CypherParser.RULE_cypherOption = 35
+CypherParser.RULE_versionNumber = 36
+CypherParser.RULE_explain = 37
+CypherParser.RULE_profile = 38
+CypherParser.RULE_configurationOption = 39
+CypherParser.RULE_statement = 40
+CypherParser.RULE_query = 41
+CypherParser.RULE_regularQuery = 42
+CypherParser.RULE_bulkImportQuery = 43
+CypherParser.RULE_singleQuery = 44
+CypherParser.RULE_periodicCommitHint = 45
+CypherParser.RULE_loadCSVQuery = 46
+CypherParser.RULE_union = 47
+CypherParser.RULE_clause = 48
+CypherParser.RULE_command = 49
+CypherParser.RULE_createUniqueConstraint = 50
+CypherParser.RULE_createNodeKeyConstraint = 51
+CypherParser.RULE_createNodePropertyExistenceConstraint = 52
+CypherParser.RULE_createRelationshipPropertyExistenceConstraint = 53
+CypherParser.RULE_createIndex = 54
+CypherParser.RULE_dropUniqueConstraint = 55
+CypherParser.RULE_dropNodeKeyConstraint = 56
+CypherParser.RULE_dropNodePropertyExistenceConstraint = 57
+CypherParser.RULE_dropRelationshipPropertyExistenceConstraint = 58
+CypherParser.RULE_dropIndex = 59
+CypherParser.RULE_index = 60
+CypherParser.RULE_uniqueConstraint = 61
+CypherParser.RULE_nodeKeyConstraint = 62
+CypherParser.RULE_nodePropertyExistenceConstraint = 63
+CypherParser.RULE_relationshipPropertyExistenceConstraint = 64
+CypherParser.RULE_relationshipPatternSyntax = 65
+CypherParser.RULE_loadCSVClause = 66
+CypherParser.RULE_matchClause = 67
+CypherParser.RULE_unwindClause = 68
+CypherParser.RULE_mergeClause = 69
+CypherParser.RULE_mergeAction = 70
+CypherParser.RULE_createClause = 71
+CypherParser.RULE_createUniqueClause = 72
+CypherParser.RULE_setClause = 73
+CypherParser.RULE_setItem = 74
+CypherParser.RULE_deleteClause = 75
+CypherParser.RULE_removeClause = 76
+CypherParser.RULE_removeItem = 77
+CypherParser.RULE_foreachClause = 78
+CypherParser.RULE_withClause = 79
+CypherParser.RULE_returnClause = 80
+CypherParser.RULE_returnBody = 81
+CypherParser.RULE_returnItems = 82
+CypherParser.RULE_returnItem = 83
+CypherParser.RULE_call = 84
+CypherParser.RULE_procedureInvocation = 85
+CypherParser.RULE_procedureInvocationBody = 86
+CypherParser.RULE_procedureArguments = 87
+CypherParser.RULE_procedureResults = 88
+CypherParser.RULE_procedureResult = 89
+CypherParser.RULE_aliasedProcedureResult = 90
+CypherParser.RULE_simpleProcedureResult = 91
+CypherParser.RULE_procedureOutput = 92
+CypherParser.RULE_order = 93
+CypherParser.RULE_skip = 94
+CypherParser.RULE_limit = 95
+CypherParser.RULE_sortItem = 96
+CypherParser.RULE_hint = 97
+CypherParser.RULE_startClause = 98
+CypherParser.RULE_startPoint = 99
+CypherParser.RULE_lookup = 100
+CypherParser.RULE_nodeLookup = 101
+CypherParser.RULE_relationshipLookup = 102
+CypherParser.RULE_identifiedIndexLookup = 103
+CypherParser.RULE_indexQuery = 104
+CypherParser.RULE_idLookup = 105
+CypherParser.RULE_literalIds = 106
+CypherParser.RULE_where = 107
+CypherParser.RULE_pattern = 108
+CypherParser.RULE_patternPart = 109
+CypherParser.RULE_anonymousPatternPart = 110
+CypherParser.RULE_patternElement = 111
+CypherParser.RULE_nodePattern = 112
+CypherParser.RULE_patternElementChain = 113
+CypherParser.RULE_relationshipPattern = 114
+CypherParser.RULE_relationshipPatternStart = 115
+CypherParser.RULE_relationshipPatternEnd = 116
+CypherParser.RULE_relationshipDetail = 117
+CypherParser.RULE_properties = 118
+CypherParser.RULE_relType = 119
+CypherParser.RULE_relationshipTypes = 120
+CypherParser.RULE_relationshipType = 121
+CypherParser.RULE_relationshipTypeOptionalColon = 122
+CypherParser.RULE_nodeLabels = 123
+CypherParser.RULE_nodeLabel = 124
+CypherParser.RULE_rangeLiteral = 125
+CypherParser.RULE_labelName = 126
+CypherParser.RULE_relTypeName = 127
+CypherParser.RULE_expression = 128
+CypherParser.RULE_orExpression = 129
+CypherParser.RULE_xorExpression = 130
+CypherParser.RULE_andExpression = 131
+CypherParser.RULE_notExpression = 132
+CypherParser.RULE_comparisonExpression = 133
+CypherParser.RULE_addOrSubtractExpression = 134
+CypherParser.RULE_multiplyDivideModuloExpression = 135
+CypherParser.RULE_powerOfExpression = 136
+CypherParser.RULE_unaryAddOrSubtractExpression = 137
+CypherParser.RULE_stringListNullOperatorExpression = 138
+CypherParser.RULE_propertyOrLabelsExpression = 139
+CypherParser.RULE_filterFunction = 140
+CypherParser.RULE_filterFunctionName = 141
+CypherParser.RULE_existsFunction = 142
+CypherParser.RULE_existsFunctionName = 143
+CypherParser.RULE_allFunction = 144
+CypherParser.RULE_allFunctionName = 145
+CypherParser.RULE_anyFunction = 146
+CypherParser.RULE_anyFunctionName = 147
+CypherParser.RULE_noneFunction = 148
+CypherParser.RULE_noneFunctionName = 149
+CypherParser.RULE_singleFunction = 150
+CypherParser.RULE_singleFunctionName = 151
+CypherParser.RULE_extractFunction = 152
+CypherParser.RULE_extractFunctionName = 153
+CypherParser.RULE_reduceFunction = 154
+CypherParser.RULE_reduceFunctionName = 155
+CypherParser.RULE_shortestPathPatternFunction = 156
+CypherParser.RULE_shortestPathFunctionName = 157
+CypherParser.RULE_allShortestPathFunctionName = 158
+CypherParser.RULE_atom = 159
+CypherParser.RULE_literal = 160
+CypherParser.RULE_stringLiteral = 161
+CypherParser.RULE_booleanLiteral = 162
+CypherParser.RULE_listLiteral = 163
+CypherParser.RULE_partialComparisonExpression = 164
+CypherParser.RULE_parenthesizedExpression = 165
+CypherParser.RULE_relationshipsPattern = 166
+CypherParser.RULE_filterExpression = 167
+CypherParser.RULE_idInColl = 168
+CypherParser.RULE_functionInvocation = 169
+CypherParser.RULE_functionInvocationBody = 170
+CypherParser.RULE_functionName = 171
+CypherParser.RULE_procedureName = 172
+CypherParser.RULE_listComprehension = 173
+CypherParser.RULE_patternComprehension = 174
+CypherParser.RULE_propertyLookup = 175
+CypherParser.RULE_caseExpression = 176
+CypherParser.RULE_caseAlternatives = 177
+CypherParser.RULE_variable = 178
+CypherParser.RULE_numberLiteral = 179
+CypherParser.RULE_mapLiteral = 180
+CypherParser.RULE_mapProjection = 181
+CypherParser.RULE_mapProjectionVariants = 182
+CypherParser.RULE_literalEntry = 183
+CypherParser.RULE_propertySelector = 184
+CypherParser.RULE_variableSelector = 185
+CypherParser.RULE_allPropertiesSelector = 186
+CypherParser.RULE_parameter = 187
+CypherParser.RULE_legacyParameter = 188
+CypherParser.RULE_newParameter = 189
+CypherParser.RULE_parameterName = 190
+CypherParser.RULE_propertyExpressions = 191
+CypherParser.RULE_propertyExpression = 192
+CypherParser.RULE_propertyKeys = 193
+CypherParser.RULE_propertyKeyName = 194
+CypherParser.RULE_integerLiteral = 195
+CypherParser.RULE_doubleLiteral = 196
+CypherParser.RULE_namespace = 197
+CypherParser.RULE_leftArrowHead = 198
+CypherParser.RULE_rightArrowHead = 199
+CypherParser.RULE_dash = 200
+CypherParser.RULE_symbolicName = 201
+CypherParser.RULE_keyword = 202
+
+function CypherContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypher
+  return this
+}
+
+CypherContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+CypherContext.prototype.constructor = CypherContext
+
+CypherContext.prototype.cypherPart = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(CypherPartContext)
+  } else {
+    return this.getTypedRuleContext(CypherPartContext, i)
+  }
+}
+
+CypherContext.prototype.EOF = function() {
+  return this.getToken(CypherParser.EOF, 0)
+}
+
+CypherContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypher(this)
+  }
+}
+
+CypherContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypher(this)
+  }
+}
+
+CypherParser.CypherContext = CypherContext
+
+CypherParser.prototype.cypher = function() {
+  var localctx = new CypherContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 0, CypherParser.RULE_cypher)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 406
+    this.cypherPart()
+    this.state = 411
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 0, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 407
+        this.match(CypherParser.T__0)
+        this.state = 408
+        this.cypherPart()
+      }
+      this.state = 413
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 0, this._ctx)
+    }
+
+    this.state = 415
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__0) {
+      this.state = 414
+      this.match(CypherParser.T__0)
+    }
+
+    this.state = 417
+    this.match(CypherParser.EOF)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CypherPartContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypherPart
+  return this
+}
+
+CypherPartContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+CypherPartContext.prototype.constructor = CypherPartContext
+
+CypherPartContext.prototype.cypherQuery = function() {
+  return this.getTypedRuleContext(CypherQueryContext, 0)
+}
+
+CypherPartContext.prototype.cypherConsoleCommand = function() {
+  return this.getTypedRuleContext(CypherConsoleCommandContext, 0)
+}
+
+CypherPartContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+CypherPartContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypherPart(this)
+  }
+}
+
+CypherPartContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypherPart(this)
+  }
+}
+
+CypherParser.CypherPartContext = CypherPartContext
+
+CypherParser.prototype.cypherPart = function() {
+  var localctx = new CypherPartContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 2, CypherParser.RULE_cypherPart)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 420
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 419
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 424
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.CYPHER:
+      case CypherParser.EXPLAIN:
+      case CypherParser.PROFILE:
+      case CypherParser.USING:
+      case CypherParser.CREATE:
+      case CypherParser.DROP:
+      case CypherParser.LOAD:
+      case CypherParser.WITH:
+      case CypherParser.OPTIONAL:
+      case CypherParser.MATCH:
+      case CypherParser.UNWIND:
+      case CypherParser.MERGE:
+      case CypherParser.SET:
+      case CypherParser.DETACH:
+      case CypherParser.DELETE:
+      case CypherParser.REMOVE:
+      case CypherParser.FOREACH:
+      case CypherParser.RETURN:
+      case CypherParser.START:
+      case CypherParser.CALL:
+        this.state = 422
+        this.cypherQuery()
+        break
+      case CypherParser.T__1:
+        this.state = 423
+        this.cypherConsoleCommand()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+    this.state = 427
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 426
+      this.match(CypherParser.SP)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CypherConsoleCommandContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypherConsoleCommand
+  return this
+}
+
+CypherConsoleCommandContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CypherConsoleCommandContext.prototype.constructor = CypherConsoleCommandContext
+
+CypherConsoleCommandContext.prototype.cypherConsoleCommandName = function() {
+  return this.getTypedRuleContext(CypherConsoleCommandNameContext, 0)
+}
+
+CypherConsoleCommandContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+CypherConsoleCommandContext.prototype.cypherConsoleCommandParameters = function() {
+  return this.getTypedRuleContext(CypherConsoleCommandParametersContext, 0)
+}
+
+CypherConsoleCommandContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypherConsoleCommand(this)
+  }
+}
+
+CypherConsoleCommandContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypherConsoleCommand(this)
+  }
+}
+
+CypherParser.CypherConsoleCommandContext = CypherConsoleCommandContext
+
+CypherParser.prototype.cypherConsoleCommand = function() {
+  var localctx = new CypherConsoleCommandContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 4, CypherParser.RULE_cypherConsoleCommand)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 429
+    this.cypherConsoleCommandName()
+    this.state = 432
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 5, this._ctx)
+    if (la_ === 1) {
+      this.state = 430
+      this.match(CypherParser.SP)
+      this.state = 431
+      this.cypherConsoleCommandParameters()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CypherConsoleCommandNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypherConsoleCommandName
+  return this
+}
+
+CypherConsoleCommandNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CypherConsoleCommandNameContext.prototype.constructor = CypherConsoleCommandNameContext
+
+CypherConsoleCommandNameContext.prototype.symbolicName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SymbolicNameContext)
+  } else {
+    return this.getTypedRuleContext(SymbolicNameContext, i)
+  }
+}
+
+CypherConsoleCommandNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypherConsoleCommandName(this)
+  }
+}
+
+CypherConsoleCommandNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypherConsoleCommandName(this)
+  }
+}
+
+CypherParser.CypherConsoleCommandNameContext = CypherConsoleCommandNameContext
+
+CypherParser.prototype.cypherConsoleCommandName = function() {
+  var localctx = new CypherConsoleCommandNameContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 6, CypherParser.RULE_cypherConsoleCommandName)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 434
+    this.match(CypherParser.T__1)
+    this.state = 435
+    this.symbolicName()
+    this.state = 440
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (_la === CypherParser.T__2) {
+      this.state = 436
+      this.match(CypherParser.T__2)
+      this.state = 437
+      this.symbolicName()
+      this.state = 442
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CypherConsoleCommandParametersContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypherConsoleCommandParameters
+  return this
+}
+
+CypherConsoleCommandParametersContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CypherConsoleCommandParametersContext.prototype.constructor = CypherConsoleCommandParametersContext
+
+CypherConsoleCommandParametersContext.prototype.cypherConsoleCommandParameter = function(
+  i
+) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(CypherConsoleCommandParameterContext)
+  } else {
+    return this.getTypedRuleContext(CypherConsoleCommandParameterContext, i)
+  }
+}
+
+CypherConsoleCommandParametersContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+CypherConsoleCommandParametersContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypherConsoleCommandParameters(this)
+  }
+}
+
+CypherConsoleCommandParametersContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypherConsoleCommandParameters(this)
+  }
+}
+
+CypherParser.CypherConsoleCommandParametersContext = CypherConsoleCommandParametersContext
+
+CypherParser.prototype.cypherConsoleCommandParameters = function() {
+  var localctx = new CypherConsoleCommandParametersContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 8, CypherParser.RULE_cypherConsoleCommandParameters)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 443
+    this.cypherConsoleCommandParameter()
+    this.state = 448
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 7, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 444
+        this.match(CypherParser.SP)
+        this.state = 445
+        this.cypherConsoleCommandParameter()
+      }
+      this.state = 450
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 7, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CypherConsoleCommandParameterContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypherConsoleCommandParameter
+  return this
+}
+
+CypherConsoleCommandParameterContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CypherConsoleCommandParameterContext.prototype.constructor = CypherConsoleCommandParameterContext
+
+CypherConsoleCommandParameterContext.prototype.url = function() {
+  return this.getTypedRuleContext(UrlContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.json = function() {
+  return this.getTypedRuleContext(JsonContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.arrowExpression = function() {
+  return this.getTypedRuleContext(ArrowExpressionContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.mapLiteral = function() {
+  return this.getTypedRuleContext(MapLiteralContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.keyValueLiteral = function() {
+  return this.getTypedRuleContext(KeyValueLiteralContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.stringLiteral = function() {
+  return this.getTypedRuleContext(StringLiteralContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.numberLiteral = function() {
+  return this.getTypedRuleContext(NumberLiteralContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.booleanLiteral = function() {
+  return this.getTypedRuleContext(BooleanLiteralContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.subCommand = function() {
+  return this.getTypedRuleContext(SubCommandContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.commandPath = function() {
+  return this.getTypedRuleContext(CommandPathContext, 0)
+}
+
+CypherConsoleCommandParameterContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypherConsoleCommandParameter(this)
+  }
+}
+
+CypherConsoleCommandParameterContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypherConsoleCommandParameter(this)
+  }
+}
+
+CypherParser.CypherConsoleCommandParameterContext = CypherConsoleCommandParameterContext
+
+CypherParser.prototype.cypherConsoleCommandParameter = function() {
+  var localctx = new CypherConsoleCommandParameterContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 10, CypherParser.RULE_cypherConsoleCommandParameter)
+  try {
+    this.state = 461
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 8, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 451
+        this.url()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 452
+        this.json()
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 453
+        this.arrowExpression()
+        break
+
+      case 4:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 454
+        this.mapLiteral()
+        break
+
+      case 5:
+        this.enterOuterAlt(localctx, 5)
+        this.state = 455
+        this.keyValueLiteral()
+        break
+
+      case 6:
+        this.enterOuterAlt(localctx, 6)
+        this.state = 456
+        this.stringLiteral()
+        break
+
+      case 7:
+        this.enterOuterAlt(localctx, 7)
+        this.state = 457
+        this.numberLiteral()
+        break
+
+      case 8:
+        this.enterOuterAlt(localctx, 8)
+        this.state = 458
+        this.booleanLiteral()
+        break
+
+      case 9:
+        this.enterOuterAlt(localctx, 9)
+        this.state = 459
+        this.subCommand()
+        break
+
+      case 10:
+        this.enterOuterAlt(localctx, 10)
+        this.state = 460
+        this.commandPath()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ArrowExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_arrowExpression
+  return this
+}
+
+ArrowExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ArrowExpressionContext.prototype.constructor = ArrowExpressionContext
+
+ArrowExpressionContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+ArrowExpressionContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+ArrowExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ArrowExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterArrowExpression(this)
+  }
+}
+
+ArrowExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitArrowExpression(this)
+  }
+}
+
+CypherParser.ArrowExpressionContext = ArrowExpressionContext
+
+CypherParser.prototype.arrowExpression = function() {
+  var localctx = new ArrowExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 12, CypherParser.RULE_arrowExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 463
+    this.symbolicName()
+    this.state = 465
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 464
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 467
+    this.match(CypherParser.T__3)
+    this.state = 469
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 468
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 471
+    this.expression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UrlContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_url
+  return this
+}
+
+UrlContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+UrlContext.prototype.constructor = UrlContext
+
+UrlContext.prototype.uri = function() {
+  return this.getTypedRuleContext(UriContext, 0)
+}
+
+UrlContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUrl(this)
+  }
+}
+
+UrlContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUrl(this)
+  }
+}
+
+CypherParser.UrlContext = UrlContext
+
+CypherParser.prototype.url = function() {
+  var localctx = new UrlContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 14, CypherParser.RULE_url)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 473
+    this.uri()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UriContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_uri
+  return this
+}
+
+UriContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+UriContext.prototype.constructor = UriContext
+
+UriContext.prototype.scheme = function() {
+  return this.getTypedRuleContext(SchemeContext, 0)
+}
+
+UriContext.prototype.host = function() {
+  return this.getTypedRuleContext(HostContext, 0)
+}
+
+UriContext.prototype.login = function() {
+  return this.getTypedRuleContext(LoginContext, 0)
+}
+
+UriContext.prototype.port = function() {
+  return this.getTypedRuleContext(PortContext, 0)
+}
+
+UriContext.prototype.path = function() {
+  return this.getTypedRuleContext(PathContext, 0)
+}
+
+UriContext.prototype.urlQuery = function() {
+  return this.getTypedRuleContext(UrlQueryContext, 0)
+}
+
+UriContext.prototype.frag = function() {
+  return this.getTypedRuleContext(FragContext, 0)
+}
+
+UriContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUri(this)
+  }
+}
+
+UriContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUri(this)
+  }
+}
+
+CypherParser.UriContext = UriContext
+
+CypherParser.prototype.uri = function() {
+  var localctx = new UriContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 16, CypherParser.RULE_uri)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 475
+    this.scheme()
+    this.state = 476
+    this.match(CypherParser.T__4)
+    this.state = 478
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 11, this._ctx)
+    if (la_ === 1) {
+      this.state = 477
+      this.login()
+    }
+    this.state = 480
+    this.host()
+    this.state = 483
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__1) {
+      this.state = 481
+      this.match(CypherParser.T__1)
+      this.state = 482
+      this.port()
+    }
+
+    this.state = 487
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__5) {
+      this.state = 485
+      this.match(CypherParser.T__5)
+      this.state = 486
+      this.path()
+    }
+
+    this.state = 490
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__9) {
+      this.state = 489
+      this.urlQuery()
+    }
+
+    this.state = 493
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__8) {
+      this.state = 492
+      this.frag()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SchemeContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_scheme
+  return this
+}
+
+SchemeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SchemeContext.prototype.constructor = SchemeContext
+
+SchemeContext.prototype.string = function() {
+  return this.getTypedRuleContext(StringContext, 0)
+}
+
+SchemeContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterScheme(this)
+  }
+}
+
+SchemeContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitScheme(this)
+  }
+}
+
+CypherParser.SchemeContext = SchemeContext
+
+CypherParser.prototype.scheme = function() {
+  var localctx = new SchemeContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 18, CypherParser.RULE_scheme)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 495
+    this.string()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function HostContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_host
+  return this
+}
+
+HostContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+HostContext.prototype.constructor = HostContext
+
+HostContext.prototype.hostname = function() {
+  return this.getTypedRuleContext(HostnameContext, 0)
+}
+
+HostContext.prototype.hostnumber = function() {
+  return this.getTypedRuleContext(HostnumberContext, 0)
+}
+
+HostContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterHost(this)
+  }
+}
+
+HostContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitHost(this)
+  }
+}
+
+CypherParser.HostContext = HostContext
+
+CypherParser.prototype.host = function() {
+  var localctx = new HostContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 20, CypherParser.RULE_host)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 498
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__5) {
+      this.state = 497
+      this.match(CypherParser.T__5)
+    }
+
+    this.state = 502
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.CYPHER:
+      case CypherParser.EXPLAIN:
+      case CypherParser.PROFILE:
+      case CypherParser.USING:
+      case CypherParser.PERIODIC:
+      case CypherParser.COMMIT:
+      case CypherParser.UNION:
+      case CypherParser.ALL:
+      case CypherParser.CREATE:
+      case CypherParser.DROP:
+      case CypherParser.INDEX:
+      case CypherParser.ON:
+      case CypherParser.CONSTRAINT:
+      case CypherParser.ASSERT:
+      case CypherParser.IS:
+      case CypherParser.UNIQUE:
+      case CypherParser.EXISTS:
+      case CypherParser.LOAD:
+      case CypherParser.CSV:
+      case CypherParser.WITH:
+      case CypherParser.HEADERS:
+      case CypherParser.FROM:
+      case CypherParser.AS:
+      case CypherParser.FIELDTERMINATOR:
+      case CypherParser.OPTIONAL:
+      case CypherParser.MATCH:
+      case CypherParser.UNWIND:
+      case CypherParser.MERGE:
+      case CypherParser.SET:
+      case CypherParser.DETACH:
+      case CypherParser.DELETE:
+      case CypherParser.REMOVE:
+      case CypherParser.FOREACH:
+      case CypherParser.IN:
+      case CypherParser.DISTINCT:
+      case CypherParser.RETURN:
+      case CypherParser.ORDER:
+      case CypherParser.BY:
+      case CypherParser.L_SKIP:
+      case CypherParser.LIMIT:
+      case CypherParser.ASCENDING:
+      case CypherParser.ASC:
+      case CypherParser.DESCENDING:
+      case CypherParser.DESC:
+      case CypherParser.JOIN:
+      case CypherParser.SCAN:
+      case CypherParser.START:
+      case CypherParser.NODE:
+      case CypherParser.RELATIONSHIP:
+      case CypherParser.REL:
+      case CypherParser.WHERE:
+      case CypherParser.SHORTESTPATH:
+      case CypherParser.ALLSHORTESTPATHS:
+      case CypherParser.OR:
+      case CypherParser.XOR:
+      case CypherParser.AND:
+      case CypherParser.NOT:
+      case CypherParser.STARTS:
+      case CypherParser.ENDS:
+      case CypherParser.CONTAINS:
+      case CypherParser.NULL:
+      case CypherParser.COUNT:
+      case CypherParser.FILTER:
+      case CypherParser.EXTRACT:
+      case CypherParser.ANY:
+      case CypherParser.NONE:
+      case CypherParser.SINGLE:
+      case CypherParser.TRUE:
+      case CypherParser.FALSE:
+      case CypherParser.REDUCE:
+      case CypherParser.CASE:
+      case CypherParser.ELSE:
+      case CypherParser.END:
+      case CypherParser.WHEN:
+      case CypherParser.THEN:
+      case CypherParser.CALL:
+      case CypherParser.YIELD:
+      case CypherParser.KEY:
+      case CypherParser.HexLetter:
+      case CypherParser.UnescapedSymbolicName:
+      case CypherParser.EscapedSymbolicName:
+        this.state = 500
+        this.hostname()
+        break
+      case CypherParser.HexInteger:
+      case CypherParser.DecimalInteger:
+      case CypherParser.OctalInteger:
+        this.state = 501
+        this.hostnumber()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function HostnameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_hostname
+  return this
+}
+
+HostnameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+HostnameContext.prototype.constructor = HostnameContext
+
+HostnameContext.prototype.string = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(StringContext)
+  } else {
+    return this.getTypedRuleContext(StringContext, i)
+  }
+}
+
+HostnameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterHostname(this)
+  }
+}
+
+HostnameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitHostname(this)
+  }
+}
+
+CypherParser.HostnameContext = HostnameContext
+
+CypherParser.prototype.hostname = function() {
+  var localctx = new HostnameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 22, CypherParser.RULE_hostname)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 504
+    this.string()
+    this.state = 509
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (_la === CypherParser.T__6) {
+      this.state = 505
+      this.match(CypherParser.T__6)
+      this.state = 506
+      this.string()
+      this.state = 511
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function HostnumberContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_hostnumber
+  return this
+}
+
+HostnumberContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+HostnumberContext.prototype.constructor = HostnumberContext
+
+HostnumberContext.prototype.urlDigits = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(UrlDigitsContext)
+  } else {
+    return this.getTypedRuleContext(UrlDigitsContext, i)
+  }
+}
+
+HostnumberContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterHostnumber(this)
+  }
+}
+
+HostnumberContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitHostnumber(this)
+  }
+}
+
+CypherParser.HostnumberContext = HostnumberContext
+
+CypherParser.prototype.hostnumber = function() {
+  var localctx = new HostnumberContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 24, CypherParser.RULE_hostnumber)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 512
+    this.urlDigits()
+    this.state = 513
+    this.match(CypherParser.T__6)
+    this.state = 514
+    this.urlDigits()
+    this.state = 515
+    this.match(CypherParser.T__6)
+    this.state = 516
+    this.urlDigits()
+    this.state = 517
+    this.match(CypherParser.T__6)
+    this.state = 518
+    this.urlDigits()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PortContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_port
+  return this
+}
+
+PortContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+PortContext.prototype.constructor = PortContext
+
+PortContext.prototype.urlDigits = function() {
+  return this.getTypedRuleContext(UrlDigitsContext, 0)
+}
+
+PortContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPort(this)
+  }
+}
+
+PortContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPort(this)
+  }
+}
+
+CypherParser.PortContext = PortContext
+
+CypherParser.prototype.port = function() {
+  var localctx = new PortContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 26, CypherParser.RULE_port)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 520
+    this.urlDigits()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PathContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_path
+  return this
+}
+
+PathContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+PathContext.prototype.constructor = PathContext
+
+PathContext.prototype.string = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(StringContext)
+  } else {
+    return this.getTypedRuleContext(StringContext, i)
+  }
+}
+
+PathContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPath(this)
+  }
+}
+
+PathContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPath(this)
+  }
+}
+
+CypherParser.PathContext = PathContext
+
+CypherParser.prototype.path = function() {
+  var localctx = new PathContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 28, CypherParser.RULE_path)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 522
+    this.string()
+    this.state = 527
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (_la === CypherParser.T__5) {
+      this.state = 523
+      this.match(CypherParser.T__5)
+      this.state = 524
+      this.string()
+      this.state = 529
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UserContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_user
+  return this
+}
+
+UserContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+UserContext.prototype.constructor = UserContext
+
+UserContext.prototype.string = function() {
+  return this.getTypedRuleContext(StringContext, 0)
+}
+
+UserContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUser(this)
+  }
+}
+
+UserContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUser(this)
+  }
+}
+
+CypherParser.UserContext = UserContext
+
+CypherParser.prototype.user = function() {
+  var localctx = new UserContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 30, CypherParser.RULE_user)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 530
+    this.string()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LoginContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_login
+  return this
+}
+
+LoginContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+LoginContext.prototype.constructor = LoginContext
+
+LoginContext.prototype.user = function() {
+  return this.getTypedRuleContext(UserContext, 0)
+}
+
+LoginContext.prototype.password = function() {
+  return this.getTypedRuleContext(PasswordContext, 0)
+}
+
+LoginContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLogin(this)
+  }
+}
+
+LoginContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLogin(this)
+  }
+}
+
+CypherParser.LoginContext = LoginContext
+
+CypherParser.prototype.login = function() {
+  var localctx = new LoginContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 32, CypherParser.RULE_login)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 532
+    this.user()
+    this.state = 533
+    this.match(CypherParser.T__1)
+    this.state = 534
+    this.password()
+    this.state = 535
+    this.match(CypherParser.T__7)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PasswordContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_password
+  return this
+}
+
+PasswordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+PasswordContext.prototype.constructor = PasswordContext
+
+PasswordContext.prototype.string = function() {
+  return this.getTypedRuleContext(StringContext, 0)
+}
+
+PasswordContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPassword(this)
+  }
+}
+
+PasswordContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPassword(this)
+  }
+}
+
+CypherParser.PasswordContext = PasswordContext
+
+CypherParser.prototype.password = function() {
+  var localctx = new PasswordContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 34, CypherParser.RULE_password)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 537
+    this.string()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function FragContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_frag
+  return this
+}
+
+FragContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+FragContext.prototype.constructor = FragContext
+
+FragContext.prototype.string = function() {
+  return this.getTypedRuleContext(StringContext, 0)
+}
+
+FragContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterFrag(this)
+  }
+}
+
+FragContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitFrag(this)
+  }
+}
+
+CypherParser.FragContext = FragContext
+
+CypherParser.prototype.frag = function() {
+  var localctx = new FragContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 36, CypherParser.RULE_frag)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 539
+    this.match(CypherParser.T__8)
+    this.state = 540
+    this.string()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UrlQueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_urlQuery
+  return this
+}
+
+UrlQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+UrlQueryContext.prototype.constructor = UrlQueryContext
+
+UrlQueryContext.prototype.search = function() {
+  return this.getTypedRuleContext(SearchContext, 0)
+}
+
+UrlQueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUrlQuery(this)
+  }
+}
+
+UrlQueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUrlQuery(this)
+  }
+}
+
+CypherParser.UrlQueryContext = UrlQueryContext
+
+CypherParser.prototype.urlQuery = function() {
+  var localctx = new UrlQueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 38, CypherParser.RULE_urlQuery)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 542
+    this.match(CypherParser.T__9)
+    this.state = 543
+    this.search()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SearchContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_search
+  return this
+}
+
+SearchContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SearchContext.prototype.constructor = SearchContext
+
+SearchContext.prototype.searchparameter = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SearchparameterContext)
+  } else {
+    return this.getTypedRuleContext(SearchparameterContext, i)
+  }
+}
+
+SearchContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSearch(this)
+  }
+}
+
+SearchContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSearch(this)
+  }
+}
+
+CypherParser.SearchContext = SearchContext
+
+CypherParser.prototype.search = function() {
+  var localctx = new SearchContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 40, CypherParser.RULE_search)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 545
+    this.searchparameter()
+    this.state = 550
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (_la === CypherParser.T__10) {
+      this.state = 546
+      this.match(CypherParser.T__10)
+      this.state = 547
+      this.searchparameter()
+      this.state = 552
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SearchparameterContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_searchparameter
+  return this
+}
+
+SearchparameterContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+SearchparameterContext.prototype.constructor = SearchparameterContext
+
+SearchparameterContext.prototype.string = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(StringContext)
+  } else {
+    return this.getTypedRuleContext(StringContext, i)
+  }
+}
+
+SearchparameterContext.prototype.urlDigits = function() {
+  return this.getTypedRuleContext(UrlDigitsContext, 0)
+}
+
+SearchparameterContext.prototype.UrlHex = function() {
+  return this.getToken(CypherParser.UrlHex, 0)
+}
+
+SearchparameterContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSearchparameter(this)
+  }
+}
+
+SearchparameterContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSearchparameter(this)
+  }
+}
+
+CypherParser.SearchparameterContext = SearchparameterContext
+
+CypherParser.prototype.searchparameter = function() {
+  var localctx = new SearchparameterContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 42, CypherParser.RULE_searchparameter)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 553
+    this.string()
+    this.state = 560
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__11) {
+      this.state = 554
+      this.match(CypherParser.T__11)
+      this.state = 558
+      this._errHandler.sync(this)
+      switch (this._input.LA(1)) {
+        case CypherParser.CYPHER:
+        case CypherParser.EXPLAIN:
+        case CypherParser.PROFILE:
+        case CypherParser.USING:
+        case CypherParser.PERIODIC:
+        case CypherParser.COMMIT:
+        case CypherParser.UNION:
+        case CypherParser.ALL:
+        case CypherParser.CREATE:
+        case CypherParser.DROP:
+        case CypherParser.INDEX:
+        case CypherParser.ON:
+        case CypherParser.CONSTRAINT:
+        case CypherParser.ASSERT:
+        case CypherParser.IS:
+        case CypherParser.UNIQUE:
+        case CypherParser.EXISTS:
+        case CypherParser.LOAD:
+        case CypherParser.CSV:
+        case CypherParser.WITH:
+        case CypherParser.HEADERS:
+        case CypherParser.FROM:
+        case CypherParser.AS:
+        case CypherParser.FIELDTERMINATOR:
+        case CypherParser.OPTIONAL:
+        case CypherParser.MATCH:
+        case CypherParser.UNWIND:
+        case CypherParser.MERGE:
+        case CypherParser.SET:
+        case CypherParser.DETACH:
+        case CypherParser.DELETE:
+        case CypherParser.REMOVE:
+        case CypherParser.FOREACH:
+        case CypherParser.IN:
+        case CypherParser.DISTINCT:
+        case CypherParser.RETURN:
+        case CypherParser.ORDER:
+        case CypherParser.BY:
+        case CypherParser.L_SKIP:
+        case CypherParser.LIMIT:
+        case CypherParser.ASCENDING:
+        case CypherParser.ASC:
+        case CypherParser.DESCENDING:
+        case CypherParser.DESC:
+        case CypherParser.JOIN:
+        case CypherParser.SCAN:
+        case CypherParser.START:
+        case CypherParser.NODE:
+        case CypherParser.RELATIONSHIP:
+        case CypherParser.REL:
+        case CypherParser.WHERE:
+        case CypherParser.SHORTESTPATH:
+        case CypherParser.ALLSHORTESTPATHS:
+        case CypherParser.OR:
+        case CypherParser.XOR:
+        case CypherParser.AND:
+        case CypherParser.NOT:
+        case CypherParser.STARTS:
+        case CypherParser.ENDS:
+        case CypherParser.CONTAINS:
+        case CypherParser.NULL:
+        case CypherParser.COUNT:
+        case CypherParser.FILTER:
+        case CypherParser.EXTRACT:
+        case CypherParser.ANY:
+        case CypherParser.NONE:
+        case CypherParser.SINGLE:
+        case CypherParser.TRUE:
+        case CypherParser.FALSE:
+        case CypherParser.REDUCE:
+        case CypherParser.CASE:
+        case CypherParser.ELSE:
+        case CypherParser.END:
+        case CypherParser.WHEN:
+        case CypherParser.THEN:
+        case CypherParser.CALL:
+        case CypherParser.YIELD:
+        case CypherParser.KEY:
+        case CypherParser.HexLetter:
+        case CypherParser.UnescapedSymbolicName:
+        case CypherParser.EscapedSymbolicName:
+          this.state = 555
+          this.string()
+          break
+        case CypherParser.HexInteger:
+        case CypherParser.DecimalInteger:
+        case CypherParser.OctalInteger:
+          this.state = 556
+          this.urlDigits()
+          break
+        case CypherParser.UrlHex:
+          this.state = 557
+          this.match(CypherParser.UrlHex)
+          break
+        default:
+          throw new antlr4.error.NoViableAltException(this)
+      }
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function StringContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_string
+  return this
+}
+
+StringContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+StringContext.prototype.constructor = StringContext
+
+StringContext.prototype.symbolicName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SymbolicNameContext)
+  } else {
+    return this.getTypedRuleContext(SymbolicNameContext, i)
+  }
+}
+
+StringContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterString(this)
+  }
+}
+
+StringContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitString(this)
+  }
+}
+
+CypherParser.StringContext = StringContext
+
+CypherParser.prototype.string = function() {
+  var localctx = new StringContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 44, CypherParser.RULE_string)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 562
+    this.symbolicName()
+    this.state = 569
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 24, this._ctx)
+    while (_alt != 1 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1 + 1) {
+        this.state = 564
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.T__6 || _la === CypherParser.T__12) {
+          this.state = 563
+          _la = this._input.LA(1)
+          if (!(_la === CypherParser.T__6 || _la === CypherParser.T__12)) {
+            this._errHandler.recoverInline(this)
+          } else {
+            this._errHandler.reportMatch(this)
+            this.consume()
+          }
+        }
+
+        this.state = 566
+        this.symbolicName()
+      }
+      this.state = 571
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 24, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UrlDigitsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_urlDigits
+  return this
+}
+
+UrlDigitsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+UrlDigitsContext.prototype.constructor = UrlDigitsContext
+
+UrlDigitsContext.prototype.integerLiteral = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(IntegerLiteralContext)
+  } else {
+    return this.getTypedRuleContext(IntegerLiteralContext, i)
+  }
+}
+
+UrlDigitsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUrlDigits(this)
+  }
+}
+
+UrlDigitsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUrlDigits(this)
+  }
+}
+
+CypherParser.UrlDigitsContext = UrlDigitsContext
+
+CypherParser.prototype.urlDigits = function() {
+  var localctx = new UrlDigitsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 46, CypherParser.RULE_urlDigits)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 573
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    do {
+      this.state = 572
+      this.integerLiteral()
+      this.state = 575
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    } while (
+      ((_la - 135) & ~0x1f) == 0 &&
+      ((1 << (_la - 135)) &
+        ((1 << (CypherParser.HexInteger - 135)) |
+          (1 << (CypherParser.DecimalInteger - 135)) |
+          (1 << (CypherParser.OctalInteger - 135)))) !==
+        0
+    )
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function JsonContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_json
+  return this
+}
+
+JsonContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+JsonContext.prototype.constructor = JsonContext
+
+JsonContext.prototype.value = function() {
+  return this.getTypedRuleContext(ValueContext, 0)
+}
+
+JsonContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterJson(this)
+  }
+}
+
+JsonContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitJson(this)
+  }
+}
+
+CypherParser.JsonContext = JsonContext
+
+CypherParser.prototype.json = function() {
+  var localctx = new JsonContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 48, CypherParser.RULE_json)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 577
+    this.value()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ObjContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_obj
+  return this
+}
+
+ObjContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ObjContext.prototype.constructor = ObjContext
+
+ObjContext.prototype.pair = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PairContext)
+  } else {
+    return this.getTypedRuleContext(PairContext, i)
+  }
+}
+
+ObjContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ObjContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterObj(this)
+  }
+}
+
+ObjContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitObj(this)
+  }
+}
+
+CypherParser.ObjContext = ObjContext
+
+CypherParser.prototype.obj = function() {
+  var localctx = new ObjContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 50, CypherParser.RULE_obj)
+  var _la = 0 // Token type
+  try {
+    this.state = 607
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 32, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 579
+        this.match(CypherParser.T__13)
+        this.state = 581
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 580
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 583
+        this.pair()
+        this.state = 585
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 584
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 597
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        while (_la === CypherParser.T__14) {
+          this.state = 587
+          this.match(CypherParser.T__14)
+          this.state = 589
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+          if (_la === CypherParser.SP) {
+            this.state = 588
+            this.match(CypherParser.SP)
+          }
+
+          this.state = 591
+          this.pair()
+          this.state = 593
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+          if (_la === CypherParser.SP) {
+            this.state = 592
+            this.match(CypherParser.SP)
+          }
+
+          this.state = 599
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+        }
+        this.state = 600
+        this.match(CypherParser.T__15)
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 602
+        this.match(CypherParser.T__13)
+        this.state = 604
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 603
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 606
+        this.match(CypherParser.T__15)
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PairContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_pair
+  return this
+}
+
+PairContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+PairContext.prototype.constructor = PairContext
+
+PairContext.prototype.stringLiteral = function() {
+  return this.getTypedRuleContext(StringLiteralContext, 0)
+}
+
+PairContext.prototype.value = function() {
+  return this.getTypedRuleContext(ValueContext, 0)
+}
+
+PairContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PairContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPair(this)
+  }
+}
+
+PairContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPair(this)
+  }
+}
+
+CypherParser.PairContext = PairContext
+
+CypherParser.prototype.pair = function() {
+  var localctx = new PairContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 52, CypherParser.RULE_pair)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 609
+    this.stringLiteral()
+    this.state = 611
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 610
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 613
+    this.match(CypherParser.T__1)
+    this.state = 615
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 614
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 617
+    this.value()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ArrayContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_array
+  return this
+}
+
+ArrayContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ArrayContext.prototype.constructor = ArrayContext
+
+ArrayContext.prototype.value = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ValueContext)
+  } else {
+    return this.getTypedRuleContext(ValueContext, i)
+  }
+}
+
+ArrayContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ArrayContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterArray(this)
+  }
+}
+
+ArrayContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitArray(this)
+  }
+}
+
+CypherParser.ArrayContext = ArrayContext
+
+CypherParser.prototype.array = function() {
+  var localctx = new ArrayContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 54, CypherParser.RULE_array)
+  var _la = 0 // Token type
+  try {
+    this.state = 647
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 41, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 619
+        this.match(CypherParser.T__16)
+        this.state = 621
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 620
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 623
+        this.value()
+        this.state = 625
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 624
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 637
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        while (_la === CypherParser.T__14) {
+          this.state = 627
+          this.match(CypherParser.T__14)
+          this.state = 629
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+          if (_la === CypherParser.SP) {
+            this.state = 628
+            this.match(CypherParser.SP)
+          }
+
+          this.state = 631
+          this.value()
+          this.state = 633
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+          if (_la === CypherParser.SP) {
+            this.state = 632
+            this.match(CypherParser.SP)
+          }
+
+          this.state = 639
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+        }
+        this.state = 640
+        this.match(CypherParser.T__17)
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 642
+        this.match(CypherParser.T__16)
+        this.state = 644
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 643
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 646
+        this.match(CypherParser.T__17)
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ValueContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_value
+  return this
+}
+
+ValueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ValueContext.prototype.constructor = ValueContext
+
+ValueContext.prototype.stringLiteral = function() {
+  return this.getTypedRuleContext(StringLiteralContext, 0)
+}
+
+ValueContext.prototype.numberLiteral = function() {
+  return this.getTypedRuleContext(NumberLiteralContext, 0)
+}
+
+ValueContext.prototype.obj = function() {
+  return this.getTypedRuleContext(ObjContext, 0)
+}
+
+ValueContext.prototype.array = function() {
+  return this.getTypedRuleContext(ArrayContext, 0)
+}
+
+ValueContext.prototype.booleanLiteral = function() {
+  return this.getTypedRuleContext(BooleanLiteralContext, 0)
+}
+
+ValueContext.prototype.NULL = function() {
+  return this.getToken(CypherParser.NULL, 0)
+}
+
+ValueContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterValue(this)
+  }
+}
+
+ValueContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitValue(this)
+  }
+}
+
+CypherParser.ValueContext = ValueContext
+
+CypherParser.prototype.value = function() {
+  var localctx = new ValueContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 56, CypherParser.RULE_value)
+  try {
+    this.state = 655
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.StringLiteral:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 649
+        this.stringLiteral()
+        break
+      case CypherParser.HexInteger:
+      case CypherParser.DecimalInteger:
+      case CypherParser.OctalInteger:
+      case CypherParser.ExponentDecimalReal:
+      case CypherParser.RegularDecimalReal:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 650
+        this.numberLiteral()
+        break
+      case CypherParser.T__13:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 651
+        this.obj()
+        break
+      case CypherParser.T__16:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 652
+        this.array()
+        break
+      case CypherParser.TRUE:
+      case CypherParser.FALSE:
+        this.enterOuterAlt(localctx, 5)
+        this.state = 653
+        this.booleanLiteral()
+        break
+      case CypherParser.NULL:
+        this.enterOuterAlt(localctx, 6)
+        this.state = 654
+        this.match(CypherParser.NULL)
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function KeyValueLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_keyValueLiteral
+  return this
+}
+
+KeyValueLiteralContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+KeyValueLiteralContext.prototype.constructor = KeyValueLiteralContext
+
+KeyValueLiteralContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+KeyValueLiteralContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+KeyValueLiteralContext.prototype.StringLiteral = function() {
+  return this.getToken(CypherParser.StringLiteral, 0)
+}
+
+KeyValueLiteralContext.prototype.numberLiteral = function() {
+  return this.getTypedRuleContext(NumberLiteralContext, 0)
+}
+
+KeyValueLiteralContext.prototype.booleanLiteral = function() {
+  return this.getTypedRuleContext(BooleanLiteralContext, 0)
+}
+
+KeyValueLiteralContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+KeyValueLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterKeyValueLiteral(this)
+  }
+}
+
+KeyValueLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitKeyValueLiteral(this)
+  }
+}
+
+CypherParser.KeyValueLiteralContext = KeyValueLiteralContext
+
+CypherParser.prototype.keyValueLiteral = function() {
+  var localctx = new KeyValueLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 58, CypherParser.RULE_keyValueLiteral)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 657
+    this.variable()
+    this.state = 658
+    this.match(CypherParser.T__1)
+    this.state = 659
+    this.match(CypherParser.SP)
+    this.state = 664
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 43, this._ctx)
+    switch (la_) {
+      case 1:
+        this.state = 660
+        this.match(CypherParser.StringLiteral)
+        break
+
+      case 2:
+        this.state = 661
+        this.numberLiteral()
+        break
+
+      case 3:
+        this.state = 662
+        this.booleanLiteral()
+        break
+
+      case 4:
+        this.state = 663
+        this.symbolicName()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CommandPathContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_commandPath
+  return this
+}
+
+CommandPathContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+CommandPathContext.prototype.constructor = CommandPathContext
+
+CommandPathContext.prototype.symbolicName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SymbolicNameContext)
+  } else {
+    return this.getTypedRuleContext(SymbolicNameContext, i)
+  }
+}
+
+CommandPathContext.prototype.numberLiteral = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(NumberLiteralContext)
+  } else {
+    return this.getTypedRuleContext(NumberLiteralContext, i)
+  }
+}
+
+CommandPathContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCommandPath(this)
+  }
+}
+
+CommandPathContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCommandPath(this)
+  }
+}
+
+CypherParser.CommandPathContext = CommandPathContext
+
+CypherParser.prototype.commandPath = function() {
+  var localctx = new CommandPathContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 60, CypherParser.RULE_commandPath)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 671
+    this._errHandler.sync(this)
+    var _alt = 1
+    do {
+      switch (_alt) {
+        case 1:
+          this.state = 666
+          this.match(CypherParser.T__5)
+          this.state = 669
+          this._errHandler.sync(this)
+          switch (this._input.LA(1)) {
+            case CypherParser.CYPHER:
+            case CypherParser.EXPLAIN:
+            case CypherParser.PROFILE:
+            case CypherParser.USING:
+            case CypherParser.PERIODIC:
+            case CypherParser.COMMIT:
+            case CypherParser.UNION:
+            case CypherParser.ALL:
+            case CypherParser.CREATE:
+            case CypherParser.DROP:
+            case CypherParser.INDEX:
+            case CypherParser.ON:
+            case CypherParser.CONSTRAINT:
+            case CypherParser.ASSERT:
+            case CypherParser.IS:
+            case CypherParser.UNIQUE:
+            case CypherParser.EXISTS:
+            case CypherParser.LOAD:
+            case CypherParser.CSV:
+            case CypherParser.WITH:
+            case CypherParser.HEADERS:
+            case CypherParser.FROM:
+            case CypherParser.AS:
+            case CypherParser.FIELDTERMINATOR:
+            case CypherParser.OPTIONAL:
+            case CypherParser.MATCH:
+            case CypherParser.UNWIND:
+            case CypherParser.MERGE:
+            case CypherParser.SET:
+            case CypherParser.DETACH:
+            case CypherParser.DELETE:
+            case CypherParser.REMOVE:
+            case CypherParser.FOREACH:
+            case CypherParser.IN:
+            case CypherParser.DISTINCT:
+            case CypherParser.RETURN:
+            case CypherParser.ORDER:
+            case CypherParser.BY:
+            case CypherParser.L_SKIP:
+            case CypherParser.LIMIT:
+            case CypherParser.ASCENDING:
+            case CypherParser.ASC:
+            case CypherParser.DESCENDING:
+            case CypherParser.DESC:
+            case CypherParser.JOIN:
+            case CypherParser.SCAN:
+            case CypherParser.START:
+            case CypherParser.NODE:
+            case CypherParser.RELATIONSHIP:
+            case CypherParser.REL:
+            case CypherParser.WHERE:
+            case CypherParser.SHORTESTPATH:
+            case CypherParser.ALLSHORTESTPATHS:
+            case CypherParser.OR:
+            case CypherParser.XOR:
+            case CypherParser.AND:
+            case CypherParser.NOT:
+            case CypherParser.STARTS:
+            case CypherParser.ENDS:
+            case CypherParser.CONTAINS:
+            case CypherParser.NULL:
+            case CypherParser.COUNT:
+            case CypherParser.FILTER:
+            case CypherParser.EXTRACT:
+            case CypherParser.ANY:
+            case CypherParser.NONE:
+            case CypherParser.SINGLE:
+            case CypherParser.TRUE:
+            case CypherParser.FALSE:
+            case CypherParser.REDUCE:
+            case CypherParser.CASE:
+            case CypherParser.ELSE:
+            case CypherParser.END:
+            case CypherParser.WHEN:
+            case CypherParser.THEN:
+            case CypherParser.CALL:
+            case CypherParser.YIELD:
+            case CypherParser.KEY:
+            case CypherParser.HexLetter:
+            case CypherParser.UnescapedSymbolicName:
+            case CypherParser.EscapedSymbolicName:
+              this.state = 667
+              this.symbolicName()
+              break
+            case CypherParser.HexInteger:
+            case CypherParser.DecimalInteger:
+            case CypherParser.OctalInteger:
+            case CypherParser.ExponentDecimalReal:
+            case CypherParser.RegularDecimalReal:
+              this.state = 668
+              this.numberLiteral()
+              break
+            default:
+              throw new antlr4.error.NoViableAltException(this)
+          }
+          break
+        default:
+          throw new antlr4.error.NoViableAltException(this)
+      }
+      this.state = 673
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 45, this._ctx)
+    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
+    this.state = 676
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__5) {
+      this.state = 675
+      this.match(CypherParser.T__5)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SubCommandContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_subCommand
+  return this
+}
+
+SubCommandContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SubCommandContext.prototype.constructor = SubCommandContext
+
+SubCommandContext.prototype.symbolicName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SymbolicNameContext)
+  } else {
+    return this.getTypedRuleContext(SymbolicNameContext, i)
+  }
+}
+
+SubCommandContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSubCommand(this)
+  }
+}
+
+SubCommandContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSubCommand(this)
+  }
+}
+
+CypherParser.SubCommandContext = SubCommandContext
+
+CypherParser.prototype.subCommand = function() {
+  var localctx = new SubCommandContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 62, CypherParser.RULE_subCommand)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 678
+    this.symbolicName()
+    this.state = 683
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (_la === CypherParser.T__2) {
+      this.state = 679
+      this.match(CypherParser.T__2)
+      this.state = 680
+      this.symbolicName()
+      this.state = 685
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CypherQueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypherQuery
+  return this
+}
+
+CypherQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+CypherQueryContext.prototype.constructor = CypherQueryContext
+
+CypherQueryContext.prototype.queryOptions = function() {
+  return this.getTypedRuleContext(QueryOptionsContext, 0)
+}
+
+CypherQueryContext.prototype.statement = function() {
+  return this.getTypedRuleContext(StatementContext, 0)
+}
+
+CypherQueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypherQuery(this)
+  }
+}
+
+CypherQueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypherQuery(this)
+  }
+}
+
+CypherParser.CypherQueryContext = CypherQueryContext
+
+CypherParser.prototype.cypherQuery = function() {
+  var localctx = new CypherQueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 64, CypherParser.RULE_cypherQuery)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 686
+    this.queryOptions()
+    this.state = 687
+    this.statement()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function QueryOptionsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_queryOptions
+  return this
+}
+
+QueryOptionsContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+QueryOptionsContext.prototype.constructor = QueryOptionsContext
+
+QueryOptionsContext.prototype.anyCypherOption = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(AnyCypherOptionContext)
+  } else {
+    return this.getTypedRuleContext(AnyCypherOptionContext, i)
+  }
+}
+
+QueryOptionsContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+QueryOptionsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterQueryOptions(this)
+  }
+}
+
+QueryOptionsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitQueryOptions(this)
+  }
+}
+
+CypherParser.QueryOptionsContext = QueryOptionsContext
+
+CypherParser.prototype.queryOptions = function() {
+  var localctx = new QueryOptionsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 66, CypherParser.RULE_queryOptions)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 695
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (
+      ((_la - 54) & ~0x1f) == 0 &&
+      ((1 << (_la - 54)) &
+        ((1 << (CypherParser.CYPHER - 54)) |
+          (1 << (CypherParser.EXPLAIN - 54)) |
+          (1 << (CypherParser.PROFILE - 54)))) !==
+        0
+    ) {
+      this.state = 689
+      this.anyCypherOption()
+      this.state = 691
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 690
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 697
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AnyCypherOptionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_anyCypherOption
+  return this
+}
+
+AnyCypherOptionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AnyCypherOptionContext.prototype.constructor = AnyCypherOptionContext
+
+AnyCypherOptionContext.prototype.cypherOption = function() {
+  return this.getTypedRuleContext(CypherOptionContext, 0)
+}
+
+AnyCypherOptionContext.prototype.explain = function() {
+  return this.getTypedRuleContext(ExplainContext, 0)
+}
+
+AnyCypherOptionContext.prototype.profile = function() {
+  return this.getTypedRuleContext(ProfileContext, 0)
+}
+
+AnyCypherOptionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAnyCypherOption(this)
+  }
+}
+
+AnyCypherOptionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAnyCypherOption(this)
+  }
+}
+
+CypherParser.AnyCypherOptionContext = AnyCypherOptionContext
+
+CypherParser.prototype.anyCypherOption = function() {
+  var localctx = new AnyCypherOptionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 68, CypherParser.RULE_anyCypherOption)
+  try {
+    this.state = 701
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.CYPHER:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 698
+        this.cypherOption()
+        break
+      case CypherParser.EXPLAIN:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 699
+        this.explain()
+        break
+      case CypherParser.PROFILE:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 700
+        this.profile()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CypherOptionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_cypherOption
+  return this
+}
+
+CypherOptionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CypherOptionContext.prototype.constructor = CypherOptionContext
+
+CypherOptionContext.prototype.CYPHER = function() {
+  return this.getToken(CypherParser.CYPHER, 0)
+}
+
+CypherOptionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+CypherOptionContext.prototype.versionNumber = function() {
+  return this.getTypedRuleContext(VersionNumberContext, 0)
+}
+
+CypherOptionContext.prototype.configurationOption = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ConfigurationOptionContext)
+  } else {
+    return this.getTypedRuleContext(ConfigurationOptionContext, i)
+  }
+}
+
+CypherOptionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCypherOption(this)
+  }
+}
+
+CypherOptionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCypherOption(this)
+  }
+}
+
+CypherParser.CypherOptionContext = CypherOptionContext
+
+CypherParser.prototype.cypherOption = function() {
+  var localctx = new CypherOptionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 70, CypherParser.RULE_cypherOption)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 703
+    this.match(CypherParser.CYPHER)
+    this.state = 706
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 51, this._ctx)
+    if (la_ === 1) {
+      this.state = 704
+      this.match(CypherParser.SP)
+      this.state = 705
+      this.versionNumber()
+    }
+    this.state = 712
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 52, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 708
+        this.match(CypherParser.SP)
+        this.state = 709
+        this.configurationOption()
+      }
+      this.state = 714
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 52, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function VersionNumberContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_versionNumber
+  return this
+}
+
+VersionNumberContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+VersionNumberContext.prototype.constructor = VersionNumberContext
+
+VersionNumberContext.prototype.RegularDecimalReal = function() {
+  return this.getToken(CypherParser.RegularDecimalReal, 0)
+}
+
+VersionNumberContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterVersionNumber(this)
+  }
+}
+
+VersionNumberContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitVersionNumber(this)
+  }
+}
+
+CypherParser.VersionNumberContext = VersionNumberContext
+
+CypherParser.prototype.versionNumber = function() {
+  var localctx = new VersionNumberContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 72, CypherParser.RULE_versionNumber)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 715
+    this.match(CypherParser.RegularDecimalReal)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ExplainContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_explain
+  return this
+}
+
+ExplainContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ExplainContext.prototype.constructor = ExplainContext
+
+ExplainContext.prototype.EXPLAIN = function() {
+  return this.getToken(CypherParser.EXPLAIN, 0)
+}
+
+ExplainContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterExplain(this)
+  }
+}
+
+ExplainContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitExplain(this)
+  }
+}
+
+CypherParser.ExplainContext = ExplainContext
+
+CypherParser.prototype.explain = function() {
+  var localctx = new ExplainContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 74, CypherParser.RULE_explain)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 717
+    this.match(CypherParser.EXPLAIN)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProfileContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_profile
+  return this
+}
+
+ProfileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ProfileContext.prototype.constructor = ProfileContext
+
+ProfileContext.prototype.PROFILE = function() {
+  return this.getToken(CypherParser.PROFILE, 0)
+}
+
+ProfileContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProfile(this)
+  }
+}
+
+ProfileContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProfile(this)
+  }
+}
+
+CypherParser.ProfileContext = ProfileContext
+
+CypherParser.prototype.profile = function() {
+  var localctx = new ProfileContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 76, CypherParser.RULE_profile)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 719
+    this.match(CypherParser.PROFILE)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ConfigurationOptionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_configurationOption
+  return this
+}
+
+ConfigurationOptionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ConfigurationOptionContext.prototype.constructor = ConfigurationOptionContext
+
+ConfigurationOptionContext.prototype.symbolicName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SymbolicNameContext)
+  } else {
+    return this.getTypedRuleContext(SymbolicNameContext, i)
+  }
+}
+
+ConfigurationOptionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ConfigurationOptionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterConfigurationOption(this)
+  }
+}
+
+ConfigurationOptionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitConfigurationOption(this)
+  }
+}
+
+CypherParser.ConfigurationOptionContext = ConfigurationOptionContext
+
+CypherParser.prototype.configurationOption = function() {
+  var localctx = new ConfigurationOptionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 78, CypherParser.RULE_configurationOption)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 721
+    this.symbolicName()
+    this.state = 723
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 722
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 725
+    this.match(CypherParser.T__11)
+    this.state = 727
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 726
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 729
+    this.symbolicName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function StatementContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_statement
+  return this
+}
+
+StatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+StatementContext.prototype.constructor = StatementContext
+
+StatementContext.prototype.command = function() {
+  return this.getTypedRuleContext(CommandContext, 0)
+}
+
+StatementContext.prototype.query = function() {
+  return this.getTypedRuleContext(QueryContext, 0)
+}
+
+StatementContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterStatement(this)
+  }
+}
+
+StatementContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitStatement(this)
+  }
+}
+
+CypherParser.StatementContext = StatementContext
+
+CypherParser.prototype.statement = function() {
+  var localctx = new StatementContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 80, CypherParser.RULE_statement)
+  try {
+    this.state = 733
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 55, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 731
+        this.command()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 732
+        this.query()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function QueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_query
+  return this
+}
+
+QueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+QueryContext.prototype.constructor = QueryContext
+
+QueryContext.prototype.regularQuery = function() {
+  return this.getTypedRuleContext(RegularQueryContext, 0)
+}
+
+QueryContext.prototype.bulkImportQuery = function() {
+  return this.getTypedRuleContext(BulkImportQueryContext, 0)
+}
+
+QueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterQuery(this)
+  }
+}
+
+QueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitQuery(this)
+  }
+}
+
+CypherParser.QueryContext = QueryContext
+
+CypherParser.prototype.query = function() {
+  var localctx = new QueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 82, CypherParser.RULE_query)
+  try {
+    this.state = 737
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.CREATE:
+      case CypherParser.LOAD:
+      case CypherParser.WITH:
+      case CypherParser.OPTIONAL:
+      case CypherParser.MATCH:
+      case CypherParser.UNWIND:
+      case CypherParser.MERGE:
+      case CypherParser.SET:
+      case CypherParser.DETACH:
+      case CypherParser.DELETE:
+      case CypherParser.REMOVE:
+      case CypherParser.FOREACH:
+      case CypherParser.RETURN:
+      case CypherParser.START:
+      case CypherParser.CALL:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 735
+        this.regularQuery()
+        break
+      case CypherParser.USING:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 736
+        this.bulkImportQuery()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RegularQueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_regularQuery
+  return this
+}
+
+RegularQueryContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RegularQueryContext.prototype.constructor = RegularQueryContext
+
+RegularQueryContext.prototype.singleQuery = function() {
+  return this.getTypedRuleContext(SingleQueryContext, 0)
+}
+
+RegularQueryContext.prototype.union = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(UnionContext)
+  } else {
+    return this.getTypedRuleContext(UnionContext, i)
+  }
+}
+
+RegularQueryContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RegularQueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRegularQuery(this)
+  }
+}
+
+RegularQueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRegularQuery(this)
+  }
+}
+
+CypherParser.RegularQueryContext = RegularQueryContext
+
+CypherParser.prototype.regularQuery = function() {
+  var localctx = new RegularQueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 84, CypherParser.RULE_regularQuery)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 739
+    this.singleQuery()
+    this.state = 746
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 58, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 741
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 740
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 743
+        this.union()
+      }
+      this.state = 748
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 58, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function BulkImportQueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_bulkImportQuery
+  return this
+}
+
+BulkImportQueryContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+BulkImportQueryContext.prototype.constructor = BulkImportQueryContext
+
+BulkImportQueryContext.prototype.periodicCommitHint = function() {
+  return this.getTypedRuleContext(PeriodicCommitHintContext, 0)
+}
+
+BulkImportQueryContext.prototype.loadCSVQuery = function() {
+  return this.getTypedRuleContext(LoadCSVQueryContext, 0)
+}
+
+BulkImportQueryContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+BulkImportQueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterBulkImportQuery(this)
+  }
+}
+
+BulkImportQueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitBulkImportQuery(this)
+  }
+}
+
+CypherParser.BulkImportQueryContext = BulkImportQueryContext
+
+CypherParser.prototype.bulkImportQuery = function() {
+  var localctx = new BulkImportQueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 86, CypherParser.RULE_bulkImportQuery)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 749
+    this.periodicCommitHint()
+    this.state = 751
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 750
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 753
+    this.loadCSVQuery()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SingleQueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_singleQuery
+  return this
+}
+
+SingleQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SingleQueryContext.prototype.constructor = SingleQueryContext
+
+SingleQueryContext.prototype.clause = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ClauseContext)
+  } else {
+    return this.getTypedRuleContext(ClauseContext, i)
+  }
+}
+
+SingleQueryContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+SingleQueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSingleQuery(this)
+  }
+}
+
+SingleQueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSingleQuery(this)
+  }
+}
+
+CypherParser.SingleQueryContext = SingleQueryContext
+
+CypherParser.prototype.singleQuery = function() {
+  var localctx = new SingleQueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 88, CypherParser.RULE_singleQuery)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 755
+    this.clause()
+    this.state = 762
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 61, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 757
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 756
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 759
+        this.clause()
+      }
+      this.state = 764
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 61, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PeriodicCommitHintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_periodicCommitHint
+  return this
+}
+
+PeriodicCommitHintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PeriodicCommitHintContext.prototype.constructor = PeriodicCommitHintContext
+
+PeriodicCommitHintContext.prototype.USING = function() {
+  return this.getToken(CypherParser.USING, 0)
+}
+
+PeriodicCommitHintContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PeriodicCommitHintContext.prototype.PERIODIC = function() {
+  return this.getToken(CypherParser.PERIODIC, 0)
+}
+
+PeriodicCommitHintContext.prototype.COMMIT = function() {
+  return this.getToken(CypherParser.COMMIT, 0)
+}
+
+PeriodicCommitHintContext.prototype.integerLiteral = function() {
+  return this.getTypedRuleContext(IntegerLiteralContext, 0)
+}
+
+PeriodicCommitHintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPeriodicCommitHint(this)
+  }
+}
+
+PeriodicCommitHintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPeriodicCommitHint(this)
+  }
+}
+
+CypherParser.PeriodicCommitHintContext = PeriodicCommitHintContext
+
+CypherParser.prototype.periodicCommitHint = function() {
+  var localctx = new PeriodicCommitHintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 90, CypherParser.RULE_periodicCommitHint)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 765
+    this.match(CypherParser.USING)
+    this.state = 766
+    this.match(CypherParser.SP)
+    this.state = 767
+    this.match(CypherParser.PERIODIC)
+    this.state = 768
+    this.match(CypherParser.SP)
+    this.state = 769
+    this.match(CypherParser.COMMIT)
+    this.state = 772
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 62, this._ctx)
+    if (la_ === 1) {
+      this.state = 770
+      this.match(CypherParser.SP)
+      this.state = 771
+      this.integerLiteral()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LoadCSVQueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_loadCSVQuery
+  return this
+}
+
+LoadCSVQueryContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+LoadCSVQueryContext.prototype.constructor = LoadCSVQueryContext
+
+LoadCSVQueryContext.prototype.loadCSVClause = function() {
+  return this.getTypedRuleContext(LoadCSVClauseContext, 0)
+}
+
+LoadCSVQueryContext.prototype.clause = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ClauseContext)
+  } else {
+    return this.getTypedRuleContext(ClauseContext, i)
+  }
+}
+
+LoadCSVQueryContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+LoadCSVQueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLoadCSVQuery(this)
+  }
+}
+
+LoadCSVQueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLoadCSVQuery(this)
+  }
+}
+
+CypherParser.LoadCSVQueryContext = LoadCSVQueryContext
+
+CypherParser.prototype.loadCSVQuery = function() {
+  var localctx = new LoadCSVQueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 92, CypherParser.RULE_loadCSVQuery)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 774
+    this.loadCSVClause()
+    this.state = 781
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 64, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 776
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 775
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 778
+        this.clause()
+      }
+      this.state = 783
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 64, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UnionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_union
+  return this
+}
+
+UnionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+UnionContext.prototype.constructor = UnionContext
+
+UnionContext.prototype.UNION = function() {
+  return this.getToken(CypherParser.UNION, 0)
+}
+
+UnionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+UnionContext.prototype.ALL = function() {
+  return this.getToken(CypherParser.ALL, 0)
+}
+
+UnionContext.prototype.singleQuery = function() {
+  return this.getTypedRuleContext(SingleQueryContext, 0)
+}
+
+UnionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUnion(this)
+  }
+}
+
+UnionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUnion(this)
+  }
+}
+
+CypherParser.UnionContext = UnionContext
+
+CypherParser.prototype.union = function() {
+  var localctx = new UnionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 94, CypherParser.RULE_union)
+  var _la = 0 // Token type
+  try {
+    this.state = 796
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 67, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 784
+        this.match(CypherParser.UNION)
+        this.state = 785
+        this.match(CypherParser.SP)
+        this.state = 786
+        this.match(CypherParser.ALL)
+        this.state = 788
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 787
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 790
+        this.singleQuery()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 791
+        this.match(CypherParser.UNION)
+        this.state = 793
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 792
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 795
+        this.singleQuery()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_clause
+  return this
+}
+
+ClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ClauseContext.prototype.constructor = ClauseContext
+
+ClauseContext.prototype.loadCSVClause = function() {
+  return this.getTypedRuleContext(LoadCSVClauseContext, 0)
+}
+
+ClauseContext.prototype.startClause = function() {
+  return this.getTypedRuleContext(StartClauseContext, 0)
+}
+
+ClauseContext.prototype.matchClause = function() {
+  return this.getTypedRuleContext(MatchClauseContext, 0)
+}
+
+ClauseContext.prototype.unwindClause = function() {
+  return this.getTypedRuleContext(UnwindClauseContext, 0)
+}
+
+ClauseContext.prototype.mergeClause = function() {
+  return this.getTypedRuleContext(MergeClauseContext, 0)
+}
+
+ClauseContext.prototype.createClause = function() {
+  return this.getTypedRuleContext(CreateClauseContext, 0)
+}
+
+ClauseContext.prototype.createUniqueClause = function() {
+  return this.getTypedRuleContext(CreateUniqueClauseContext, 0)
+}
+
+ClauseContext.prototype.setClause = function() {
+  return this.getTypedRuleContext(SetClauseContext, 0)
+}
+
+ClauseContext.prototype.deleteClause = function() {
+  return this.getTypedRuleContext(DeleteClauseContext, 0)
+}
+
+ClauseContext.prototype.removeClause = function() {
+  return this.getTypedRuleContext(RemoveClauseContext, 0)
+}
+
+ClauseContext.prototype.foreachClause = function() {
+  return this.getTypedRuleContext(ForeachClauseContext, 0)
+}
+
+ClauseContext.prototype.withClause = function() {
+  return this.getTypedRuleContext(WithClauseContext, 0)
+}
+
+ClauseContext.prototype.returnClause = function() {
+  return this.getTypedRuleContext(ReturnClauseContext, 0)
+}
+
+ClauseContext.prototype.call = function() {
+  return this.getTypedRuleContext(CallContext, 0)
+}
+
+ClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterClause(this)
+  }
+}
+
+ClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitClause(this)
+  }
+}
+
+CypherParser.ClauseContext = ClauseContext
+
+CypherParser.prototype.clause = function() {
+  var localctx = new ClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 96, CypherParser.RULE_clause)
+  try {
+    this.state = 812
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 68, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 798
+        this.loadCSVClause()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 799
+        this.startClause()
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 800
+        this.matchClause()
+        break
+
+      case 4:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 801
+        this.unwindClause()
+        break
+
+      case 5:
+        this.enterOuterAlt(localctx, 5)
+        this.state = 802
+        this.mergeClause()
+        break
+
+      case 6:
+        this.enterOuterAlt(localctx, 6)
+        this.state = 803
+        this.createClause()
+        break
+
+      case 7:
+        this.enterOuterAlt(localctx, 7)
+        this.state = 804
+        this.createUniqueClause()
+        break
+
+      case 8:
+        this.enterOuterAlt(localctx, 8)
+        this.state = 805
+        this.setClause()
+        break
+
+      case 9:
+        this.enterOuterAlt(localctx, 9)
+        this.state = 806
+        this.deleteClause()
+        break
+
+      case 10:
+        this.enterOuterAlt(localctx, 10)
+        this.state = 807
+        this.removeClause()
+        break
+
+      case 11:
+        this.enterOuterAlt(localctx, 11)
+        this.state = 808
+        this.foreachClause()
+        break
+
+      case 12:
+        this.enterOuterAlt(localctx, 12)
+        this.state = 809
+        this.withClause()
+        break
+
+      case 13:
+        this.enterOuterAlt(localctx, 13)
+        this.state = 810
+        this.returnClause()
+        break
+
+      case 14:
+        this.enterOuterAlt(localctx, 14)
+        this.state = 811
+        this.call()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CommandContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_command
+  return this
+}
+
+CommandContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+CommandContext.prototype.constructor = CommandContext
+
+CommandContext.prototype.createIndex = function() {
+  return this.getTypedRuleContext(CreateIndexContext, 0)
+}
+
+CommandContext.prototype.dropIndex = function() {
+  return this.getTypedRuleContext(DropIndexContext, 0)
+}
+
+CommandContext.prototype.createUniqueConstraint = function() {
+  return this.getTypedRuleContext(CreateUniqueConstraintContext, 0)
+}
+
+CommandContext.prototype.dropUniqueConstraint = function() {
+  return this.getTypedRuleContext(DropUniqueConstraintContext, 0)
+}
+
+CommandContext.prototype.createNodeKeyConstraint = function() {
+  return this.getTypedRuleContext(CreateNodeKeyConstraintContext, 0)
+}
+
+CommandContext.prototype.dropNodeKeyConstraint = function() {
+  return this.getTypedRuleContext(DropNodeKeyConstraintContext, 0)
+}
+
+CommandContext.prototype.createNodePropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(
+    CreateNodePropertyExistenceConstraintContext,
+    0
+  )
+}
+
+CommandContext.prototype.dropNodePropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(DropNodePropertyExistenceConstraintContext, 0)
+}
+
+CommandContext.prototype.createRelationshipPropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(
+    CreateRelationshipPropertyExistenceConstraintContext,
+    0
+  )
+}
+
+CommandContext.prototype.dropRelationshipPropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(
+    DropRelationshipPropertyExistenceConstraintContext,
+    0
+  )
+}
+
+CommandContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCommand(this)
+  }
+}
+
+CommandContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCommand(this)
+  }
+}
+
+CypherParser.CommandContext = CommandContext
+
+CypherParser.prototype.command = function() {
+  var localctx = new CommandContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 98, CypherParser.RULE_command)
+  try {
+    this.state = 824
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 69, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 814
+        this.createIndex()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 815
+        this.dropIndex()
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 816
+        this.createUniqueConstraint()
+        break
+
+      case 4:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 817
+        this.dropUniqueConstraint()
+        break
+
+      case 5:
+        this.enterOuterAlt(localctx, 5)
+        this.state = 818
+        this.createNodeKeyConstraint()
+        break
+
+      case 6:
+        this.enterOuterAlt(localctx, 6)
+        this.state = 819
+        this.dropNodeKeyConstraint()
+        break
+
+      case 7:
+        this.enterOuterAlt(localctx, 7)
+        this.state = 820
+        this.createNodePropertyExistenceConstraint()
+        break
+
+      case 8:
+        this.enterOuterAlt(localctx, 8)
+        this.state = 821
+        this.dropNodePropertyExistenceConstraint()
+        break
+
+      case 9:
+        this.enterOuterAlt(localctx, 9)
+        this.state = 822
+        this.createRelationshipPropertyExistenceConstraint()
+        break
+
+      case 10:
+        this.enterOuterAlt(localctx, 10)
+        this.state = 823
+        this.dropRelationshipPropertyExistenceConstraint()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CreateUniqueConstraintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_createUniqueConstraint
+  return this
+}
+
+CreateUniqueConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CreateUniqueConstraintContext.prototype.constructor = CreateUniqueConstraintContext
+
+CreateUniqueConstraintContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+CreateUniqueConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+CreateUniqueConstraintContext.prototype.uniqueConstraint = function() {
+  return this.getTypedRuleContext(UniqueConstraintContext, 0)
+}
+
+CreateUniqueConstraintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCreateUniqueConstraint(this)
+  }
+}
+
+CreateUniqueConstraintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCreateUniqueConstraint(this)
+  }
+}
+
+CypherParser.CreateUniqueConstraintContext = CreateUniqueConstraintContext
+
+CypherParser.prototype.createUniqueConstraint = function() {
+  var localctx = new CreateUniqueConstraintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 100, CypherParser.RULE_createUniqueConstraint)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 826
+    this.match(CypherParser.CREATE)
+    this.state = 827
+    this.match(CypherParser.SP)
+    this.state = 828
+    this.uniqueConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CreateNodeKeyConstraintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_createNodeKeyConstraint
+  return this
+}
+
+CreateNodeKeyConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CreateNodeKeyConstraintContext.prototype.constructor = CreateNodeKeyConstraintContext
+
+CreateNodeKeyConstraintContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+CreateNodeKeyConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+CreateNodeKeyConstraintContext.prototype.nodeKeyConstraint = function() {
+  return this.getTypedRuleContext(NodeKeyConstraintContext, 0)
+}
+
+CreateNodeKeyConstraintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCreateNodeKeyConstraint(this)
+  }
+}
+
+CreateNodeKeyConstraintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCreateNodeKeyConstraint(this)
+  }
+}
+
+CypherParser.CreateNodeKeyConstraintContext = CreateNodeKeyConstraintContext
+
+CypherParser.prototype.createNodeKeyConstraint = function() {
+  var localctx = new CreateNodeKeyConstraintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 102, CypherParser.RULE_createNodeKeyConstraint)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 830
+    this.match(CypherParser.CREATE)
+    this.state = 831
+    this.match(CypherParser.SP)
+    this.state = 832
+    this.nodeKeyConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CreateNodePropertyExistenceConstraintContext(
+  parser,
+  parent,
+  invokingState
+) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_createNodePropertyExistenceConstraint
+  return this
+}
+
+CreateNodePropertyExistenceConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CreateNodePropertyExistenceConstraintContext.prototype.constructor = CreateNodePropertyExistenceConstraintContext
+
+CreateNodePropertyExistenceConstraintContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+CreateNodePropertyExistenceConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+CreateNodePropertyExistenceConstraintContext.prototype.nodePropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(NodePropertyExistenceConstraintContext, 0)
+}
+
+CreateNodePropertyExistenceConstraintContext.prototype.enterRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.enterCreateNodePropertyExistenceConstraint(this)
+  }
+}
+
+CreateNodePropertyExistenceConstraintContext.prototype.exitRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.exitCreateNodePropertyExistenceConstraint(this)
+  }
+}
+
+CypherParser.CreateNodePropertyExistenceConstraintContext = CreateNodePropertyExistenceConstraintContext
+
+CypherParser.prototype.createNodePropertyExistenceConstraint = function() {
+  var localctx = new CreateNodePropertyExistenceConstraintContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    104,
+    CypherParser.RULE_createNodePropertyExistenceConstraint
+  )
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 834
+    this.match(CypherParser.CREATE)
+    this.state = 835
+    this.match(CypherParser.SP)
+    this.state = 836
+    this.nodePropertyExistenceConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CreateRelationshipPropertyExistenceConstraintContext(
+  parser,
+  parent,
+  invokingState
+) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex =
+    CypherParser.RULE_createRelationshipPropertyExistenceConstraint
+  return this
+}
+
+CreateRelationshipPropertyExistenceConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CreateRelationshipPropertyExistenceConstraintContext.prototype.constructor = CreateRelationshipPropertyExistenceConstraintContext
+
+CreateRelationshipPropertyExistenceConstraintContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+CreateRelationshipPropertyExistenceConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+CreateRelationshipPropertyExistenceConstraintContext.prototype.relationshipPropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(
+    RelationshipPropertyExistenceConstraintContext,
+    0
+  )
+}
+
+CreateRelationshipPropertyExistenceConstraintContext.prototype.enterRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.enterCreateRelationshipPropertyExistenceConstraint(this)
+  }
+}
+
+CreateRelationshipPropertyExistenceConstraintContext.prototype.exitRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.exitCreateRelationshipPropertyExistenceConstraint(this)
+  }
+}
+
+CypherParser.CreateRelationshipPropertyExistenceConstraintContext = CreateRelationshipPropertyExistenceConstraintContext
+
+CypherParser.prototype.createRelationshipPropertyExistenceConstraint = function() {
+  var localctx = new CreateRelationshipPropertyExistenceConstraintContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    106,
+    CypherParser.RULE_createRelationshipPropertyExistenceConstraint
+  )
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 838
+    this.match(CypherParser.CREATE)
+    this.state = 839
+    this.match(CypherParser.SP)
+    this.state = 840
+    this.relationshipPropertyExistenceConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CreateIndexContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_createIndex
+  return this
+}
+
+CreateIndexContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+CreateIndexContext.prototype.constructor = CreateIndexContext
+
+CreateIndexContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+CreateIndexContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+CreateIndexContext.prototype.index = function() {
+  return this.getTypedRuleContext(IndexContext, 0)
+}
+
+CreateIndexContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCreateIndex(this)
+  }
+}
+
+CreateIndexContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCreateIndex(this)
+  }
+}
+
+CypherParser.CreateIndexContext = CreateIndexContext
+
+CypherParser.prototype.createIndex = function() {
+  var localctx = new CreateIndexContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 108, CypherParser.RULE_createIndex)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 842
+    this.match(CypherParser.CREATE)
+    this.state = 843
+    this.match(CypherParser.SP)
+    this.state = 844
+    this.index()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DropUniqueConstraintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_dropUniqueConstraint
+  return this
+}
+
+DropUniqueConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+DropUniqueConstraintContext.prototype.constructor = DropUniqueConstraintContext
+
+DropUniqueConstraintContext.prototype.DROP = function() {
+  return this.getToken(CypherParser.DROP, 0)
+}
+
+DropUniqueConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+DropUniqueConstraintContext.prototype.uniqueConstraint = function() {
+  return this.getTypedRuleContext(UniqueConstraintContext, 0)
+}
+
+DropUniqueConstraintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterDropUniqueConstraint(this)
+  }
+}
+
+DropUniqueConstraintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitDropUniqueConstraint(this)
+  }
+}
+
+CypherParser.DropUniqueConstraintContext = DropUniqueConstraintContext
+
+CypherParser.prototype.dropUniqueConstraint = function() {
+  var localctx = new DropUniqueConstraintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 110, CypherParser.RULE_dropUniqueConstraint)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 846
+    this.match(CypherParser.DROP)
+    this.state = 847
+    this.match(CypherParser.SP)
+    this.state = 848
+    this.uniqueConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DropNodeKeyConstraintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_dropNodeKeyConstraint
+  return this
+}
+
+DropNodeKeyConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+DropNodeKeyConstraintContext.prototype.constructor = DropNodeKeyConstraintContext
+
+DropNodeKeyConstraintContext.prototype.DROP = function() {
+  return this.getToken(CypherParser.DROP, 0)
+}
+
+DropNodeKeyConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+DropNodeKeyConstraintContext.prototype.nodeKeyConstraint = function() {
+  return this.getTypedRuleContext(NodeKeyConstraintContext, 0)
+}
+
+DropNodeKeyConstraintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterDropNodeKeyConstraint(this)
+  }
+}
+
+DropNodeKeyConstraintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitDropNodeKeyConstraint(this)
+  }
+}
+
+CypherParser.DropNodeKeyConstraintContext = DropNodeKeyConstraintContext
+
+CypherParser.prototype.dropNodeKeyConstraint = function() {
+  var localctx = new DropNodeKeyConstraintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 112, CypherParser.RULE_dropNodeKeyConstraint)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 850
+    this.match(CypherParser.DROP)
+    this.state = 851
+    this.match(CypherParser.SP)
+    this.state = 852
+    this.nodeKeyConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DropNodePropertyExistenceConstraintContext(
+  parser,
+  parent,
+  invokingState
+) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_dropNodePropertyExistenceConstraint
+  return this
+}
+
+DropNodePropertyExistenceConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+DropNodePropertyExistenceConstraintContext.prototype.constructor = DropNodePropertyExistenceConstraintContext
+
+DropNodePropertyExistenceConstraintContext.prototype.DROP = function() {
+  return this.getToken(CypherParser.DROP, 0)
+}
+
+DropNodePropertyExistenceConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+DropNodePropertyExistenceConstraintContext.prototype.nodePropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(NodePropertyExistenceConstraintContext, 0)
+}
+
+DropNodePropertyExistenceConstraintContext.prototype.enterRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.enterDropNodePropertyExistenceConstraint(this)
+  }
+}
+
+DropNodePropertyExistenceConstraintContext.prototype.exitRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.exitDropNodePropertyExistenceConstraint(this)
+  }
+}
+
+CypherParser.DropNodePropertyExistenceConstraintContext = DropNodePropertyExistenceConstraintContext
+
+CypherParser.prototype.dropNodePropertyExistenceConstraint = function() {
+  var localctx = new DropNodePropertyExistenceConstraintContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    114,
+    CypherParser.RULE_dropNodePropertyExistenceConstraint
+  )
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 854
+    this.match(CypherParser.DROP)
+    this.state = 855
+    this.match(CypherParser.SP)
+    this.state = 856
+    this.nodePropertyExistenceConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DropRelationshipPropertyExistenceConstraintContext(
+  parser,
+  parent,
+  invokingState
+) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_dropRelationshipPropertyExistenceConstraint
+  return this
+}
+
+DropRelationshipPropertyExistenceConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+DropRelationshipPropertyExistenceConstraintContext.prototype.constructor = DropRelationshipPropertyExistenceConstraintContext
+
+DropRelationshipPropertyExistenceConstraintContext.prototype.DROP = function() {
+  return this.getToken(CypherParser.DROP, 0)
+}
+
+DropRelationshipPropertyExistenceConstraintContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+DropRelationshipPropertyExistenceConstraintContext.prototype.relationshipPropertyExistenceConstraint = function() {
+  return this.getTypedRuleContext(
+    RelationshipPropertyExistenceConstraintContext,
+    0
+  )
+}
+
+DropRelationshipPropertyExistenceConstraintContext.prototype.enterRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.enterDropRelationshipPropertyExistenceConstraint(this)
+  }
+}
+
+DropRelationshipPropertyExistenceConstraintContext.prototype.exitRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.exitDropRelationshipPropertyExistenceConstraint(this)
+  }
+}
+
+CypherParser.DropRelationshipPropertyExistenceConstraintContext = DropRelationshipPropertyExistenceConstraintContext
+
+CypherParser.prototype.dropRelationshipPropertyExistenceConstraint = function() {
+  var localctx = new DropRelationshipPropertyExistenceConstraintContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    116,
+    CypherParser.RULE_dropRelationshipPropertyExistenceConstraint
+  )
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 858
+    this.match(CypherParser.DROP)
+    this.state = 859
+    this.match(CypherParser.SP)
+    this.state = 860
+    this.relationshipPropertyExistenceConstraint()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DropIndexContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_dropIndex
+  return this
+}
+
+DropIndexContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+DropIndexContext.prototype.constructor = DropIndexContext
+
+DropIndexContext.prototype.DROP = function() {
+  return this.getToken(CypherParser.DROP, 0)
+}
+
+DropIndexContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+DropIndexContext.prototype.index = function() {
+  return this.getTypedRuleContext(IndexContext, 0)
+}
+
+DropIndexContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterDropIndex(this)
+  }
+}
+
+DropIndexContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitDropIndex(this)
+  }
+}
+
+CypherParser.DropIndexContext = DropIndexContext
+
+CypherParser.prototype.dropIndex = function() {
+  var localctx = new DropIndexContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 118, CypherParser.RULE_dropIndex)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 862
+    this.match(CypherParser.DROP)
+    this.state = 863
+    this.match(CypherParser.SP)
+    this.state = 864
+    this.index()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function IndexContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_index
+  return this
+}
+
+IndexContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+IndexContext.prototype.constructor = IndexContext
+
+IndexContext.prototype.INDEX = function() {
+  return this.getToken(CypherParser.INDEX, 0)
+}
+
+IndexContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+IndexContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+IndexContext.prototype.nodeLabel = function() {
+  return this.getTypedRuleContext(NodeLabelContext, 0)
+}
+
+IndexContext.prototype.propertyKeys = function() {
+  return this.getTypedRuleContext(PropertyKeysContext, 0)
+}
+
+IndexContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterIndex(this)
+  }
+}
+
+IndexContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitIndex(this)
+  }
+}
+
+CypherParser.IndexContext = IndexContext
+
+CypherParser.prototype.index = function() {
+  var localctx = new IndexContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 120, CypherParser.RULE_index)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 866
+    this.match(CypherParser.INDEX)
+    this.state = 867
+    this.match(CypherParser.SP)
+    this.state = 868
+    this.match(CypherParser.ON)
+    this.state = 870
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 869
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 872
+    this.nodeLabel()
+    this.state = 874
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 873
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 876
+    this.match(CypherParser.T__18)
+    this.state = 878
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 877
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 880
+    this.propertyKeys()
+    this.state = 882
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 881
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 884
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UniqueConstraintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_uniqueConstraint
+  return this
+}
+
+UniqueConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+UniqueConstraintContext.prototype.constructor = UniqueConstraintContext
+
+UniqueConstraintContext.prototype.CONSTRAINT = function() {
+  return this.getToken(CypherParser.CONSTRAINT, 0)
+}
+
+UniqueConstraintContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+UniqueConstraintContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+UniqueConstraintContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+UniqueConstraintContext.prototype.nodeLabel = function() {
+  return this.getTypedRuleContext(NodeLabelContext, 0)
+}
+
+UniqueConstraintContext.prototype.ASSERT = function() {
+  return this.getToken(CypherParser.ASSERT, 0)
+}
+
+UniqueConstraintContext.prototype.propertyExpression = function() {
+  return this.getTypedRuleContext(PropertyExpressionContext, 0)
+}
+
+UniqueConstraintContext.prototype.IS = function() {
+  return this.getToken(CypherParser.IS, 0)
+}
+
+UniqueConstraintContext.prototype.UNIQUE = function() {
+  return this.getToken(CypherParser.UNIQUE, 0)
+}
+
+UniqueConstraintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUniqueConstraint(this)
+  }
+}
+
+UniqueConstraintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUniqueConstraint(this)
+  }
+}
+
+CypherParser.UniqueConstraintContext = UniqueConstraintContext
+
+CypherParser.prototype.uniqueConstraint = function() {
+  var localctx = new UniqueConstraintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 122, CypherParser.RULE_uniqueConstraint)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 886
+    this.match(CypherParser.CONSTRAINT)
+    this.state = 887
+    this.match(CypherParser.SP)
+    this.state = 888
+    this.match(CypherParser.ON)
+    this.state = 890
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 889
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 892
+    this.match(CypherParser.T__18)
+    this.state = 894
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 893
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 896
+    this.variable()
+    this.state = 897
+    this.nodeLabel()
+    this.state = 899
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 898
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 901
+    this.match(CypherParser.T__19)
+    this.state = 903
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 902
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 905
+    this.match(CypherParser.ASSERT)
+    this.state = 906
+    this.match(CypherParser.SP)
+    this.state = 907
+    this.propertyExpression()
+    this.state = 908
+    this.match(CypherParser.SP)
+    this.state = 909
+    this.match(CypherParser.IS)
+    this.state = 910
+    this.match(CypherParser.SP)
+    this.state = 911
+    this.match(CypherParser.UNIQUE)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NodeKeyConstraintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_nodeKeyConstraint
+  return this
+}
+
+NodeKeyConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+NodeKeyConstraintContext.prototype.constructor = NodeKeyConstraintContext
+
+NodeKeyConstraintContext.prototype.CONSTRAINT = function() {
+  return this.getToken(CypherParser.CONSTRAINT, 0)
+}
+
+NodeKeyConstraintContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+NodeKeyConstraintContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+NodeKeyConstraintContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+NodeKeyConstraintContext.prototype.nodeLabel = function() {
+  return this.getTypedRuleContext(NodeLabelContext, 0)
+}
+
+NodeKeyConstraintContext.prototype.ASSERT = function() {
+  return this.getToken(CypherParser.ASSERT, 0)
+}
+
+NodeKeyConstraintContext.prototype.propertyExpressions = function() {
+  return this.getTypedRuleContext(PropertyExpressionsContext, 0)
+}
+
+NodeKeyConstraintContext.prototype.IS = function() {
+  return this.getToken(CypherParser.IS, 0)
+}
+
+NodeKeyConstraintContext.prototype.NODE = function() {
+  return this.getToken(CypherParser.NODE, 0)
+}
+
+NodeKeyConstraintContext.prototype.KEY = function() {
+  return this.getToken(CypherParser.KEY, 0)
+}
+
+NodeKeyConstraintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNodeKeyConstraint(this)
+  }
+}
+
+NodeKeyConstraintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNodeKeyConstraint(this)
+  }
+}
+
+CypherParser.NodeKeyConstraintContext = NodeKeyConstraintContext
+
+CypherParser.prototype.nodeKeyConstraint = function() {
+  var localctx = new NodeKeyConstraintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 124, CypherParser.RULE_nodeKeyConstraint)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 913
+    this.match(CypherParser.CONSTRAINT)
+    this.state = 914
+    this.match(CypherParser.SP)
+    this.state = 915
+    this.match(CypherParser.ON)
+    this.state = 917
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 916
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 919
+    this.match(CypherParser.T__18)
+    this.state = 921
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 920
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 923
+    this.variable()
+    this.state = 924
+    this.nodeLabel()
+    this.state = 926
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 925
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 928
+    this.match(CypherParser.T__19)
+    this.state = 930
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 929
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 932
+    this.match(CypherParser.ASSERT)
+    this.state = 933
+    this.match(CypherParser.SP)
+    this.state = 934
+    this.match(CypherParser.T__18)
+    this.state = 936
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 935
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 938
+    this.propertyExpressions()
+    this.state = 940
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 939
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 942
+    this.match(CypherParser.T__19)
+    this.state = 943
+    this.match(CypherParser.SP)
+    this.state = 944
+    this.match(CypherParser.IS)
+    this.state = 945
+    this.match(CypherParser.SP)
+    this.state = 946
+    this.match(CypherParser.NODE)
+    this.state = 947
+    this.match(CypherParser.SP)
+    this.state = 948
+    this.match(CypherParser.KEY)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NodePropertyExistenceConstraintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_nodePropertyExistenceConstraint
+  return this
+}
+
+NodePropertyExistenceConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+NodePropertyExistenceConstraintContext.prototype.constructor = NodePropertyExistenceConstraintContext
+
+NodePropertyExistenceConstraintContext.prototype.CONSTRAINT = function() {
+  return this.getToken(CypherParser.CONSTRAINT, 0)
+}
+
+NodePropertyExistenceConstraintContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+NodePropertyExistenceConstraintContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+NodePropertyExistenceConstraintContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+NodePropertyExistenceConstraintContext.prototype.nodeLabel = function() {
+  return this.getTypedRuleContext(NodeLabelContext, 0)
+}
+
+NodePropertyExistenceConstraintContext.prototype.ASSERT = function() {
+  return this.getToken(CypherParser.ASSERT, 0)
+}
+
+NodePropertyExistenceConstraintContext.prototype.EXISTS = function() {
+  return this.getToken(CypherParser.EXISTS, 0)
+}
+
+NodePropertyExistenceConstraintContext.prototype.propertyExpression = function() {
+  return this.getTypedRuleContext(PropertyExpressionContext, 0)
+}
+
+NodePropertyExistenceConstraintContext.prototype.enterRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.enterNodePropertyExistenceConstraint(this)
+  }
+}
+
+NodePropertyExistenceConstraintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNodePropertyExistenceConstraint(this)
+  }
+}
+
+CypherParser.NodePropertyExistenceConstraintContext = NodePropertyExistenceConstraintContext
+
+CypherParser.prototype.nodePropertyExistenceConstraint = function() {
+  var localctx = new NodePropertyExistenceConstraintContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    126,
+    CypherParser.RULE_nodePropertyExistenceConstraint
+  )
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 950
+    this.match(CypherParser.CONSTRAINT)
+    this.state = 951
+    this.match(CypherParser.SP)
+    this.state = 952
+    this.match(CypherParser.ON)
+    this.state = 954
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 953
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 956
+    this.match(CypherParser.T__18)
+    this.state = 957
+    this.variable()
+    this.state = 958
+    this.nodeLabel()
+    this.state = 959
+    this.match(CypherParser.T__19)
+    this.state = 961
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 960
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 963
+    this.match(CypherParser.ASSERT)
+    this.state = 964
+    this.match(CypherParser.SP)
+    this.state = 965
+    this.match(CypherParser.EXISTS)
+    this.state = 967
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 966
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 969
+    this.match(CypherParser.T__18)
+    this.state = 970
+    this.propertyExpression()
+    this.state = 971
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipPropertyExistenceConstraintContext(
+  parser,
+  parent,
+  invokingState
+) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipPropertyExistenceConstraint
+  return this
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipPropertyExistenceConstraintContext.prototype.constructor = RelationshipPropertyExistenceConstraintContext
+
+RelationshipPropertyExistenceConstraintContext.prototype.CONSTRAINT = function() {
+  return this.getToken(CypherParser.CONSTRAINT, 0)
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.relationshipPatternSyntax = function() {
+  return this.getTypedRuleContext(RelationshipPatternSyntaxContext, 0)
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.ASSERT = function() {
+  return this.getToken(CypherParser.ASSERT, 0)
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.EXISTS = function() {
+  return this.getToken(CypherParser.EXISTS, 0)
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.propertyExpression = function() {
+  return this.getTypedRuleContext(PropertyExpressionContext, 0)
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.enterRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipPropertyExistenceConstraint(this)
+  }
+}
+
+RelationshipPropertyExistenceConstraintContext.prototype.exitRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipPropertyExistenceConstraint(this)
+  }
+}
+
+CypherParser.RelationshipPropertyExistenceConstraintContext = RelationshipPropertyExistenceConstraintContext
+
+CypherParser.prototype.relationshipPropertyExistenceConstraint = function() {
+  var localctx = new RelationshipPropertyExistenceConstraintContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    128,
+    CypherParser.RULE_relationshipPropertyExistenceConstraint
+  )
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 973
+    this.match(CypherParser.CONSTRAINT)
+    this.state = 974
+    this.match(CypherParser.SP)
+    this.state = 975
+    this.match(CypherParser.ON)
+    this.state = 977
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 976
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 979
+    this.relationshipPatternSyntax()
+    this.state = 981
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 980
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 983
+    this.match(CypherParser.ASSERT)
+    this.state = 984
+    this.match(CypherParser.SP)
+    this.state = 985
+    this.match(CypherParser.EXISTS)
+    this.state = 987
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 986
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 989
+    this.match(CypherParser.T__18)
+    this.state = 990
+    this.propertyExpression()
+    this.state = 991
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipPatternSyntaxContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipPatternSyntax
+  return this
+}
+
+RelationshipPatternSyntaxContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipPatternSyntaxContext.prototype.constructor = RelationshipPatternSyntaxContext
+
+RelationshipPatternSyntaxContext.prototype.dash = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(DashContext)
+  } else {
+    return this.getTypedRuleContext(DashContext, i)
+  }
+}
+
+RelationshipPatternSyntaxContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+RelationshipPatternSyntaxContext.prototype.relType = function() {
+  return this.getTypedRuleContext(RelTypeContext, 0)
+}
+
+RelationshipPatternSyntaxContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RelationshipPatternSyntaxContext.prototype.rightArrowHead = function() {
+  return this.getTypedRuleContext(RightArrowHeadContext, 0)
+}
+
+RelationshipPatternSyntaxContext.prototype.leftArrowHead = function() {
+  return this.getTypedRuleContext(LeftArrowHeadContext, 0)
+}
+
+RelationshipPatternSyntaxContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipPatternSyntax(this)
+  }
+}
+
+RelationshipPatternSyntaxContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipPatternSyntax(this)
+  }
+}
+
+CypherParser.RelationshipPatternSyntaxContext = RelationshipPatternSyntaxContext
+
+CypherParser.prototype.relationshipPatternSyntax = function() {
+  var localctx = new RelationshipPatternSyntaxContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 130, CypherParser.RULE_relationshipPatternSyntax)
+  var _la = 0 // Token type
+  try {
+    this.state = 1046
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 96, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 993
+        this.match(CypherParser.T__18)
+        this.state = 995
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 994
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 997
+        this.match(CypherParser.T__19)
+        this.state = 998
+        this.dash()
+        this.state = 999
+        this.match(CypherParser.T__16)
+        this.state = 1000
+        this.variable()
+        this.state = 1001
+        this.relType()
+        this.state = 1002
+        this.match(CypherParser.T__17)
+        this.state = 1003
+        this.dash()
+        this.state = 1004
+        this.match(CypherParser.T__18)
+        this.state = 1006
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1005
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1008
+        this.match(CypherParser.T__19)
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1010
+        this.match(CypherParser.T__18)
+        this.state = 1012
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1011
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1014
+        this.match(CypherParser.T__19)
+        this.state = 1015
+        this.dash()
+        this.state = 1016
+        this.match(CypherParser.T__16)
+        this.state = 1017
+        this.variable()
+        this.state = 1018
+        this.relType()
+        this.state = 1019
+        this.match(CypherParser.T__17)
+        this.state = 1020
+        this.dash()
+        this.state = 1021
+        this.rightArrowHead()
+        this.state = 1022
+        this.match(CypherParser.T__18)
+        this.state = 1024
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1023
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1026
+        this.match(CypherParser.T__19)
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 1028
+        this.match(CypherParser.T__18)
+        this.state = 1030
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1029
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1032
+        this.match(CypherParser.T__19)
+        this.state = 1033
+        this.leftArrowHead()
+        this.state = 1034
+        this.dash()
+        this.state = 1035
+        this.match(CypherParser.T__16)
+        this.state = 1036
+        this.variable()
+        this.state = 1037
+        this.relType()
+        this.state = 1038
+        this.match(CypherParser.T__17)
+        this.state = 1039
+        this.dash()
+        this.state = 1040
+        this.match(CypherParser.T__18)
+        this.state = 1042
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1041
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1044
+        this.match(CypherParser.T__19)
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LoadCSVClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_loadCSVClause
+  return this
+}
+
+LoadCSVClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+LoadCSVClauseContext.prototype.constructor = LoadCSVClauseContext
+
+LoadCSVClauseContext.prototype.LOAD = function() {
+  return this.getToken(CypherParser.LOAD, 0)
+}
+
+LoadCSVClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+LoadCSVClauseContext.prototype.CSV = function() {
+  return this.getToken(CypherParser.CSV, 0)
+}
+
+LoadCSVClauseContext.prototype.FROM = function() {
+  return this.getToken(CypherParser.FROM, 0)
+}
+
+LoadCSVClauseContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+LoadCSVClauseContext.prototype.AS = function() {
+  return this.getToken(CypherParser.AS, 0)
+}
+
+LoadCSVClauseContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+LoadCSVClauseContext.prototype.WITH = function() {
+  return this.getToken(CypherParser.WITH, 0)
+}
+
+LoadCSVClauseContext.prototype.HEADERS = function() {
+  return this.getToken(CypherParser.HEADERS, 0)
+}
+
+LoadCSVClauseContext.prototype.FIELDTERMINATOR = function() {
+  return this.getToken(CypherParser.FIELDTERMINATOR, 0)
+}
+
+LoadCSVClauseContext.prototype.StringLiteral = function() {
+  return this.getToken(CypherParser.StringLiteral, 0)
+}
+
+LoadCSVClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLoadCSVClause(this)
+  }
+}
+
+LoadCSVClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLoadCSVClause(this)
+  }
+}
+
+CypherParser.LoadCSVClauseContext = LoadCSVClauseContext
+
+CypherParser.prototype.loadCSVClause = function() {
+  var localctx = new LoadCSVClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 132, CypherParser.RULE_loadCSVClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1048
+    this.match(CypherParser.LOAD)
+    this.state = 1049
+    this.match(CypherParser.SP)
+    this.state = 1050
+    this.match(CypherParser.CSV)
+    this.state = 1051
+    this.match(CypherParser.SP)
+    this.state = 1056
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.WITH) {
+      this.state = 1052
+      this.match(CypherParser.WITH)
+      this.state = 1053
+      this.match(CypherParser.SP)
+      this.state = 1054
+      this.match(CypherParser.HEADERS)
+      this.state = 1055
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1058
+    this.match(CypherParser.FROM)
+    this.state = 1059
+    this.match(CypherParser.SP)
+    this.state = 1060
+    this.expression()
+    this.state = 1061
+    this.match(CypherParser.SP)
+    this.state = 1062
+    this.match(CypherParser.AS)
+    this.state = 1063
+    this.match(CypherParser.SP)
+    this.state = 1064
+    this.variable()
+    this.state = 1065
+    this.match(CypherParser.SP)
+    this.state = 1069
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.FIELDTERMINATOR) {
+      this.state = 1066
+      this.match(CypherParser.FIELDTERMINATOR)
+      this.state = 1067
+      this.match(CypherParser.SP)
+      this.state = 1068
+      this.match(CypherParser.StringLiteral)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function MatchClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_matchClause
+  return this
+}
+
+MatchClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+MatchClauseContext.prototype.constructor = MatchClauseContext
+
+MatchClauseContext.prototype.MATCH = function() {
+  return this.getToken(CypherParser.MATCH, 0)
+}
+
+MatchClauseContext.prototype.pattern = function() {
+  return this.getTypedRuleContext(PatternContext, 0)
+}
+
+MatchClauseContext.prototype.OPTIONAL = function() {
+  return this.getToken(CypherParser.OPTIONAL, 0)
+}
+
+MatchClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+MatchClauseContext.prototype.hint = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(HintContext)
+  } else {
+    return this.getTypedRuleContext(HintContext, i)
+  }
+}
+
+MatchClauseContext.prototype.where = function() {
+  return this.getTypedRuleContext(WhereContext, 0)
+}
+
+MatchClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterMatchClause(this)
+  }
+}
+
+MatchClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitMatchClause(this)
+  }
+}
+
+CypherParser.MatchClauseContext = MatchClauseContext
+
+CypherParser.prototype.matchClause = function() {
+  var localctx = new MatchClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 134, CypherParser.RULE_matchClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1073
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.OPTIONAL) {
+      this.state = 1071
+      this.match(CypherParser.OPTIONAL)
+      this.state = 1072
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1075
+    this.match(CypherParser.MATCH)
+    this.state = 1077
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1076
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1079
+    this.pattern()
+    this.state = 1083
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 101, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1080
+        this.hint()
+      }
+      this.state = 1085
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 101, this._ctx)
+    }
+
+    this.state = 1090
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 103, this._ctx)
+    if (la_ === 1) {
+      this.state = 1087
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1086
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1089
+      this.where()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UnwindClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_unwindClause
+  return this
+}
+
+UnwindClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+UnwindClauseContext.prototype.constructor = UnwindClauseContext
+
+UnwindClauseContext.prototype.UNWIND = function() {
+  return this.getToken(CypherParser.UNWIND, 0)
+}
+
+UnwindClauseContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+UnwindClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+UnwindClauseContext.prototype.AS = function() {
+  return this.getToken(CypherParser.AS, 0)
+}
+
+UnwindClauseContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+UnwindClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUnwindClause(this)
+  }
+}
+
+UnwindClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUnwindClause(this)
+  }
+}
+
+CypherParser.UnwindClauseContext = UnwindClauseContext
+
+CypherParser.prototype.unwindClause = function() {
+  var localctx = new UnwindClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 136, CypherParser.RULE_unwindClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1092
+    this.match(CypherParser.UNWIND)
+    this.state = 1094
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1093
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1096
+    this.expression()
+    this.state = 1097
+    this.match(CypherParser.SP)
+    this.state = 1098
+    this.match(CypherParser.AS)
+    this.state = 1099
+    this.match(CypherParser.SP)
+    this.state = 1100
+    this.variable()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function MergeClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_mergeClause
+  return this
+}
+
+MergeClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+MergeClauseContext.prototype.constructor = MergeClauseContext
+
+MergeClauseContext.prototype.MERGE = function() {
+  return this.getToken(CypherParser.MERGE, 0)
+}
+
+MergeClauseContext.prototype.patternPart = function() {
+  return this.getTypedRuleContext(PatternPartContext, 0)
+}
+
+MergeClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+MergeClauseContext.prototype.mergeAction = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(MergeActionContext)
+  } else {
+    return this.getTypedRuleContext(MergeActionContext, i)
+  }
+}
+
+MergeClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterMergeClause(this)
+  }
+}
+
+MergeClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitMergeClause(this)
+  }
+}
+
+CypherParser.MergeClauseContext = MergeClauseContext
+
+CypherParser.prototype.mergeClause = function() {
+  var localctx = new MergeClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 138, CypherParser.RULE_mergeClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1102
+    this.match(CypherParser.MERGE)
+    this.state = 1104
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1103
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1106
+    this.patternPart()
+    this.state = 1111
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 106, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1107
+        this.match(CypherParser.SP)
+        this.state = 1108
+        this.mergeAction()
+      }
+      this.state = 1113
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 106, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function MergeActionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_mergeAction
+  return this
+}
+
+MergeActionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+MergeActionContext.prototype.constructor = MergeActionContext
+
+MergeActionContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+MergeActionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+MergeActionContext.prototype.MATCH = function() {
+  return this.getToken(CypherParser.MATCH, 0)
+}
+
+MergeActionContext.prototype.setClause = function() {
+  return this.getTypedRuleContext(SetClauseContext, 0)
+}
+
+MergeActionContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+MergeActionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterMergeAction(this)
+  }
+}
+
+MergeActionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitMergeAction(this)
+  }
+}
+
+CypherParser.MergeActionContext = MergeActionContext
+
+CypherParser.prototype.mergeAction = function() {
+  var localctx = new MergeActionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 140, CypherParser.RULE_mergeAction)
+  try {
+    this.state = 1124
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 107, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1114
+        this.match(CypherParser.ON)
+        this.state = 1115
+        this.match(CypherParser.SP)
+        this.state = 1116
+        this.match(CypherParser.MATCH)
+        this.state = 1117
+        this.match(CypherParser.SP)
+        this.state = 1118
+        this.setClause()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1119
+        this.match(CypherParser.ON)
+        this.state = 1120
+        this.match(CypherParser.SP)
+        this.state = 1121
+        this.match(CypherParser.CREATE)
+        this.state = 1122
+        this.match(CypherParser.SP)
+        this.state = 1123
+        this.setClause()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CreateClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_createClause
+  return this
+}
+
+CreateClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CreateClauseContext.prototype.constructor = CreateClauseContext
+
+CreateClauseContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+CreateClauseContext.prototype.pattern = function() {
+  return this.getTypedRuleContext(PatternContext, 0)
+}
+
+CreateClauseContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+CreateClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCreateClause(this)
+  }
+}
+
+CreateClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCreateClause(this)
+  }
+}
+
+CypherParser.CreateClauseContext = CreateClauseContext
+
+CypherParser.prototype.createClause = function() {
+  var localctx = new CreateClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 142, CypherParser.RULE_createClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1126
+    this.match(CypherParser.CREATE)
+    this.state = 1128
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1127
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1130
+    this.pattern()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CreateUniqueClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_createUniqueClause
+  return this
+}
+
+CreateUniqueClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CreateUniqueClauseContext.prototype.constructor = CreateUniqueClauseContext
+
+CreateUniqueClauseContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+CreateUniqueClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+CreateUniqueClauseContext.prototype.UNIQUE = function() {
+  return this.getToken(CypherParser.UNIQUE, 0)
+}
+
+CreateUniqueClauseContext.prototype.pattern = function() {
+  return this.getTypedRuleContext(PatternContext, 0)
+}
+
+CreateUniqueClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCreateUniqueClause(this)
+  }
+}
+
+CreateUniqueClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCreateUniqueClause(this)
+  }
+}
+
+CypherParser.CreateUniqueClauseContext = CreateUniqueClauseContext
+
+CypherParser.prototype.createUniqueClause = function() {
+  var localctx = new CreateUniqueClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 144, CypherParser.RULE_createUniqueClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1132
+    this.match(CypherParser.CREATE)
+    this.state = 1133
+    this.match(CypherParser.SP)
+    this.state = 1134
+    this.match(CypherParser.UNIQUE)
+    this.state = 1136
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1135
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1138
+    this.pattern()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SetClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_setClause
+  return this
+}
+
+SetClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SetClauseContext.prototype.constructor = SetClauseContext
+
+SetClauseContext.prototype.SET = function() {
+  return this.getToken(CypherParser.SET, 0)
+}
+
+SetClauseContext.prototype.setItem = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SetItemContext)
+  } else {
+    return this.getTypedRuleContext(SetItemContext, i)
+  }
+}
+
+SetClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+SetClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSetClause(this)
+  }
+}
+
+SetClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSetClause(this)
+  }
+}
+
+CypherParser.SetClauseContext = SetClauseContext
+
+CypherParser.prototype.setClause = function() {
+  var localctx = new SetClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 146, CypherParser.RULE_setClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1140
+    this.match(CypherParser.SET)
+    this.state = 1142
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1141
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1144
+    this.setItem()
+    this.state = 1155
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 113, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1146
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1145
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1148
+        this.match(CypherParser.T__14)
+        this.state = 1150
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1149
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1152
+        this.setItem()
+      }
+      this.state = 1157
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 113, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SetItemContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_setItem
+  return this
+}
+
+SetItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SetItemContext.prototype.constructor = SetItemContext
+
+SetItemContext.prototype.propertyExpression = function() {
+  return this.getTypedRuleContext(PropertyExpressionContext, 0)
+}
+
+SetItemContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+SetItemContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+SetItemContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+SetItemContext.prototype.nodeLabels = function() {
+  return this.getTypedRuleContext(NodeLabelsContext, 0)
+}
+
+SetItemContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSetItem(this)
+  }
+}
+
+SetItemContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSetItem(this)
+  }
+}
+
+CypherParser.SetItemContext = SetItemContext
+
+CypherParser.prototype.setItem = function() {
+  var localctx = new SetItemContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 148, CypherParser.RULE_setItem)
+  var _la = 0 // Token type
+  try {
+    this.state = 1194
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 121, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1158
+        this.propertyExpression()
+        this.state = 1160
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1159
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1162
+        this.match(CypherParser.T__11)
+        this.state = 1164
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1163
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1166
+        this.expression()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1168
+        this.variable()
+        this.state = 1170
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1169
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1172
+        this.match(CypherParser.T__11)
+        this.state = 1174
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1173
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1176
+        this.expression()
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 1178
+        this.variable()
+        this.state = 1180
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1179
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1182
+        this.match(CypherParser.T__20)
+        this.state = 1184
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1183
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1186
+        this.expression()
+        break
+
+      case 4:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 1188
+        this.variable()
+        this.state = 1190
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1189
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1192
+        this.nodeLabels()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DeleteClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_deleteClause
+  return this
+}
+
+DeleteClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+DeleteClauseContext.prototype.constructor = DeleteClauseContext
+
+DeleteClauseContext.prototype.DELETE = function() {
+  return this.getToken(CypherParser.DELETE, 0)
+}
+
+DeleteClauseContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+DeleteClauseContext.prototype.DETACH = function() {
+  return this.getToken(CypherParser.DETACH, 0)
+}
+
+DeleteClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+DeleteClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterDeleteClause(this)
+  }
+}
+
+DeleteClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitDeleteClause(this)
+  }
+}
+
+CypherParser.DeleteClauseContext = DeleteClauseContext
+
+CypherParser.prototype.deleteClause = function() {
+  var localctx = new DeleteClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 150, CypherParser.RULE_deleteClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1198
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.DETACH) {
+      this.state = 1196
+      this.match(CypherParser.DETACH)
+      this.state = 1197
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1200
+    this.match(CypherParser.DELETE)
+    this.state = 1202
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1201
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1204
+    this.expression()
+    this.state = 1215
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 126, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1206
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1205
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1208
+        this.match(CypherParser.T__14)
+        this.state = 1210
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1209
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1212
+        this.expression()
+      }
+      this.state = 1217
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 126, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RemoveClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_removeClause
+  return this
+}
+
+RemoveClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RemoveClauseContext.prototype.constructor = RemoveClauseContext
+
+RemoveClauseContext.prototype.REMOVE = function() {
+  return this.getToken(CypherParser.REMOVE, 0)
+}
+
+RemoveClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RemoveClauseContext.prototype.removeItem = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(RemoveItemContext)
+  } else {
+    return this.getTypedRuleContext(RemoveItemContext, i)
+  }
+}
+
+RemoveClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRemoveClause(this)
+  }
+}
+
+RemoveClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRemoveClause(this)
+  }
+}
+
+CypherParser.RemoveClauseContext = RemoveClauseContext
+
+CypherParser.prototype.removeClause = function() {
+  var localctx = new RemoveClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 152, CypherParser.RULE_removeClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1218
+    this.match(CypherParser.REMOVE)
+    this.state = 1219
+    this.match(CypherParser.SP)
+    this.state = 1220
+    this.removeItem()
+    this.state = 1231
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 129, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1222
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1221
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1224
+        this.match(CypherParser.T__14)
+        this.state = 1226
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1225
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1228
+        this.removeItem()
+      }
+      this.state = 1233
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 129, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RemoveItemContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_removeItem
+  return this
+}
+
+RemoveItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+RemoveItemContext.prototype.constructor = RemoveItemContext
+
+RemoveItemContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+RemoveItemContext.prototype.nodeLabels = function() {
+  return this.getTypedRuleContext(NodeLabelsContext, 0)
+}
+
+RemoveItemContext.prototype.propertyExpression = function() {
+  return this.getTypedRuleContext(PropertyExpressionContext, 0)
+}
+
+RemoveItemContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRemoveItem(this)
+  }
+}
+
+RemoveItemContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRemoveItem(this)
+  }
+}
+
+CypherParser.RemoveItemContext = RemoveItemContext
+
+CypherParser.prototype.removeItem = function() {
+  var localctx = new RemoveItemContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 154, CypherParser.RULE_removeItem)
+  try {
+    this.state = 1238
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 130, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1234
+        this.variable()
+        this.state = 1235
+        this.nodeLabels()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1237
+        this.propertyExpression()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ForeachClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_foreachClause
+  return this
+}
+
+ForeachClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ForeachClauseContext.prototype.constructor = ForeachClauseContext
+
+ForeachClauseContext.prototype.FOREACH = function() {
+  return this.getToken(CypherParser.FOREACH, 0)
+}
+
+ForeachClauseContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+ForeachClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ForeachClauseContext.prototype.IN = function() {
+  return this.getToken(CypherParser.IN, 0)
+}
+
+ForeachClauseContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+ForeachClauseContext.prototype.clause = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ClauseContext)
+  } else {
+    return this.getTypedRuleContext(ClauseContext, i)
+  }
+}
+
+ForeachClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterForeachClause(this)
+  }
+}
+
+ForeachClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitForeachClause(this)
+  }
+}
+
+CypherParser.ForeachClauseContext = ForeachClauseContext
+
+CypherParser.prototype.foreachClause = function() {
+  var localctx = new ForeachClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 156, CypherParser.RULE_foreachClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1240
+    this.match(CypherParser.FOREACH)
+    this.state = 1242
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1241
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1244
+    this.match(CypherParser.T__18)
+    this.state = 1246
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1245
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1248
+    this.variable()
+    this.state = 1249
+    this.match(CypherParser.SP)
+    this.state = 1250
+    this.match(CypherParser.IN)
+    this.state = 1251
+    this.match(CypherParser.SP)
+    this.state = 1252
+    this.expression()
+    this.state = 1254
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1253
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1256
+    this.match(CypherParser.T__21)
+    this.state = 1259
+    this._errHandler.sync(this)
+    var _alt = 1
+    do {
+      switch (_alt) {
+        case 1:
+          this.state = 1257
+          this.match(CypherParser.SP)
+          this.state = 1258
+          this.clause()
+          break
+        default:
+          throw new antlr4.error.NoViableAltException(this)
+      }
+      this.state = 1261
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 134, this._ctx)
+    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
+    this.state = 1264
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1263
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1266
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function WithClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_withClause
+  return this
+}
+
+WithClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+WithClauseContext.prototype.constructor = WithClauseContext
+
+WithClauseContext.prototype.WITH = function() {
+  return this.getToken(CypherParser.WITH, 0)
+}
+
+WithClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+WithClauseContext.prototype.returnBody = function() {
+  return this.getTypedRuleContext(ReturnBodyContext, 0)
+}
+
+WithClauseContext.prototype.DISTINCT = function() {
+  return this.getToken(CypherParser.DISTINCT, 0)
+}
+
+WithClauseContext.prototype.where = function() {
+  return this.getTypedRuleContext(WhereContext, 0)
+}
+
+WithClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterWithClause(this)
+  }
+}
+
+WithClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitWithClause(this)
+  }
+}
+
+CypherParser.WithClauseContext = WithClauseContext
+
+CypherParser.prototype.withClause = function() {
+  var localctx = new WithClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 158, CypherParser.RULE_withClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1268
+    this.match(CypherParser.WITH)
+    this.state = 1273
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 137, this._ctx)
+    if (la_ === 1) {
+      this.state = 1270
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1269
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1272
+      this.match(CypherParser.DISTINCT)
+    }
+    this.state = 1275
+    this.match(CypherParser.SP)
+    this.state = 1276
+    this.returnBody()
+    this.state = 1281
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 139, this._ctx)
+    if (la_ === 1) {
+      this.state = 1278
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1277
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1280
+      this.where()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ReturnClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_returnClause
+  return this
+}
+
+ReturnClauseContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ReturnClauseContext.prototype.constructor = ReturnClauseContext
+
+ReturnClauseContext.prototype.RETURN = function() {
+  return this.getToken(CypherParser.RETURN, 0)
+}
+
+ReturnClauseContext.prototype.returnBody = function() {
+  return this.getTypedRuleContext(ReturnBodyContext, 0)
+}
+
+ReturnClauseContext.prototype.DISTINCT = function() {
+  return this.getToken(CypherParser.DISTINCT, 0)
+}
+
+ReturnClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ReturnClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterReturnClause(this)
+  }
+}
+
+ReturnClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitReturnClause(this)
+  }
+}
+
+CypherParser.ReturnClauseContext = ReturnClauseContext
+
+CypherParser.prototype.returnClause = function() {
+  var localctx = new ReturnClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 160, CypherParser.RULE_returnClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1283
+    this.match(CypherParser.RETURN)
+    this.state = 1288
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 141, this._ctx)
+    if (la_ === 1) {
+      this.state = 1285
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1284
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1287
+      this.match(CypherParser.DISTINCT)
+    }
+    this.state = 1291
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1290
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1293
+    this.returnBody()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ReturnBodyContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_returnBody
+  return this
+}
+
+ReturnBodyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ReturnBodyContext.prototype.constructor = ReturnBodyContext
+
+ReturnBodyContext.prototype.returnItems = function() {
+  return this.getTypedRuleContext(ReturnItemsContext, 0)
+}
+
+ReturnBodyContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ReturnBodyContext.prototype.order = function() {
+  return this.getTypedRuleContext(OrderContext, 0)
+}
+
+ReturnBodyContext.prototype.skip = function() {
+  return this.getTypedRuleContext(SkipContext, 0)
+}
+
+ReturnBodyContext.prototype.limit = function() {
+  return this.getTypedRuleContext(LimitContext, 0)
+}
+
+ReturnBodyContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterReturnBody(this)
+  }
+}
+
+ReturnBodyContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitReturnBody(this)
+  }
+}
+
+CypherParser.ReturnBodyContext = ReturnBodyContext
+
+CypherParser.prototype.returnBody = function() {
+  var localctx = new ReturnBodyContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 162, CypherParser.RULE_returnBody)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1295
+    this.returnItems()
+    this.state = 1298
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 143, this._ctx)
+    if (la_ === 1) {
+      this.state = 1296
+      this.match(CypherParser.SP)
+      this.state = 1297
+      this.order()
+    }
+    this.state = 1302
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 144, this._ctx)
+    if (la_ === 1) {
+      this.state = 1300
+      this.match(CypherParser.SP)
+      this.state = 1301
+      this.skip()
+    }
+    this.state = 1306
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 145, this._ctx)
+    if (la_ === 1) {
+      this.state = 1304
+      this.match(CypherParser.SP)
+      this.state = 1305
+      this.limit()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ReturnItemsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_returnItems
+  return this
+}
+
+ReturnItemsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ReturnItemsContext.prototype.constructor = ReturnItemsContext
+
+ReturnItemsContext.prototype.returnItem = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ReturnItemContext)
+  } else {
+    return this.getTypedRuleContext(ReturnItemContext, i)
+  }
+}
+
+ReturnItemsContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ReturnItemsContext.prototype.procedureInvocation = function() {
+  return this.getTypedRuleContext(ProcedureInvocationContext, 0)
+}
+
+ReturnItemsContext.prototype.procedureResults = function() {
+  return this.getTypedRuleContext(ProcedureResultsContext, 0)
+}
+
+ReturnItemsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterReturnItems(this)
+  }
+}
+
+ReturnItemsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitReturnItems(this)
+  }
+}
+
+CypherParser.ReturnItemsContext = ReturnItemsContext
+
+CypherParser.prototype.returnItems = function() {
+  var localctx = new ReturnItemsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 164, CypherParser.RULE_returnItems)
+  var _la = 0 // Token type
+  try {
+    this.state = 1343
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 154, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1308
+        this.match(CypherParser.T__22)
+        this.state = 1319
+        this._errHandler.sync(this)
+        var _alt = this._interp.adaptivePredict(this._input, 148, this._ctx)
+        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+          if (_alt === 1) {
+            this.state = 1310
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1309
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1312
+            this.match(CypherParser.T__14)
+            this.state = 1314
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1313
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1316
+            this.returnItem()
+          }
+          this.state = 1321
+          this._errHandler.sync(this)
+          _alt = this._interp.adaptivePredict(this._input, 148, this._ctx)
+        }
+
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1322
+        this.returnItem()
+        this.state = 1333
+        this._errHandler.sync(this)
+        var _alt = this._interp.adaptivePredict(this._input, 151, this._ctx)
+        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+          if (_alt === 1) {
+            this.state = 1324
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1323
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1326
+            this.match(CypherParser.T__14)
+            this.state = 1328
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1327
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1330
+            this.returnItem()
+          }
+          this.state = 1335
+          this._errHandler.sync(this)
+          _alt = this._interp.adaptivePredict(this._input, 151, this._ctx)
+        }
+
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 1336
+        this.procedureInvocation()
+        this.state = 1338
+        this._errHandler.sync(this)
+        var la_ = this._interp.adaptivePredict(this._input, 152, this._ctx)
+        if (la_ === 1) {
+          this.state = 1337
+          this.match(CypherParser.SP)
+        }
+        this.state = 1341
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.YIELD) {
+          this.state = 1340
+          this.procedureResults()
+        }
+
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ReturnItemContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_returnItem
+  return this
+}
+
+ReturnItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ReturnItemContext.prototype.constructor = ReturnItemContext
+
+ReturnItemContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+ReturnItemContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ReturnItemContext.prototype.AS = function() {
+  return this.getToken(CypherParser.AS, 0)
+}
+
+ReturnItemContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+ReturnItemContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterReturnItem(this)
+  }
+}
+
+ReturnItemContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitReturnItem(this)
+  }
+}
+
+CypherParser.ReturnItemContext = ReturnItemContext
+
+CypherParser.prototype.returnItem = function() {
+  var localctx = new ReturnItemContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 166, CypherParser.RULE_returnItem)
+  try {
+    this.state = 1352
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 155, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1345
+        this.expression()
+        this.state = 1346
+        this.match(CypherParser.SP)
+        this.state = 1347
+        this.match(CypherParser.AS)
+        this.state = 1348
+        this.match(CypherParser.SP)
+        this.state = 1349
+        this.variable()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1351
+        this.expression()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CallContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_call
+  return this
+}
+
+CallContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+CallContext.prototype.constructor = CallContext
+
+CallContext.prototype.CALL = function() {
+  return this.getToken(CypherParser.CALL, 0)
+}
+
+CallContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+CallContext.prototype.procedureInvocation = function() {
+  return this.getTypedRuleContext(ProcedureInvocationContext, 0)
+}
+
+CallContext.prototype.procedureResults = function() {
+  return this.getTypedRuleContext(ProcedureResultsContext, 0)
+}
+
+CallContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCall(this)
+  }
+}
+
+CallContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCall(this)
+  }
+}
+
+CypherParser.CallContext = CallContext
+
+CypherParser.prototype.call = function() {
+  var localctx = new CallContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 168, CypherParser.RULE_call)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1354
+    this.match(CypherParser.CALL)
+    this.state = 1355
+    this.match(CypherParser.SP)
+    this.state = 1356
+    this.procedureInvocation()
+    this.state = 1358
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 156, this._ctx)
+    if (la_ === 1) {
+      this.state = 1357
+      this.match(CypherParser.SP)
+    }
+    this.state = 1361
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.YIELD) {
+      this.state = 1360
+      this.procedureResults()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProcedureInvocationContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_procedureInvocation
+  return this
+}
+
+ProcedureInvocationContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ProcedureInvocationContext.prototype.constructor = ProcedureInvocationContext
+
+ProcedureInvocationContext.prototype.procedureInvocationBody = function() {
+  return this.getTypedRuleContext(ProcedureInvocationBodyContext, 0)
+}
+
+ProcedureInvocationContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+ProcedureInvocationContext.prototype.procedureArguments = function() {
+  return this.getTypedRuleContext(ProcedureArgumentsContext, 0)
+}
+
+ProcedureInvocationContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProcedureInvocation(this)
+  }
+}
+
+ProcedureInvocationContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProcedureInvocation(this)
+  }
+}
+
+CypherParser.ProcedureInvocationContext = ProcedureInvocationContext
+
+CypherParser.prototype.procedureInvocation = function() {
+  var localctx = new ProcedureInvocationContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 170, CypherParser.RULE_procedureInvocation)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1363
+    this.procedureInvocationBody()
+    this.state = 1365
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 158, this._ctx)
+    if (la_ === 1) {
+      this.state = 1364
+      this.match(CypherParser.SP)
+    }
+    this.state = 1368
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__18) {
+      this.state = 1367
+      this.procedureArguments()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProcedureInvocationBodyContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_procedureInvocationBody
+  return this
+}
+
+ProcedureInvocationBodyContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ProcedureInvocationBodyContext.prototype.constructor = ProcedureInvocationBodyContext
+
+ProcedureInvocationBodyContext.prototype.namespace = function() {
+  return this.getTypedRuleContext(NamespaceContext, 0)
+}
+
+ProcedureInvocationBodyContext.prototype.procedureName = function() {
+  return this.getTypedRuleContext(ProcedureNameContext, 0)
+}
+
+ProcedureInvocationBodyContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProcedureInvocationBody(this)
+  }
+}
+
+ProcedureInvocationBodyContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProcedureInvocationBody(this)
+  }
+}
+
+CypherParser.ProcedureInvocationBodyContext = ProcedureInvocationBodyContext
+
+CypherParser.prototype.procedureInvocationBody = function() {
+  var localctx = new ProcedureInvocationBodyContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 172, CypherParser.RULE_procedureInvocationBody)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1370
+    this.namespace()
+    this.state = 1371
+    this.procedureName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProcedureArgumentsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_procedureArguments
+  return this
+}
+
+ProcedureArgumentsContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ProcedureArgumentsContext.prototype.constructor = ProcedureArgumentsContext
+
+ProcedureArgumentsContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ProcedureArgumentsContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+ProcedureArgumentsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProcedureArguments(this)
+  }
+}
+
+ProcedureArgumentsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProcedureArguments(this)
+  }
+}
+
+CypherParser.ProcedureArgumentsContext = ProcedureArgumentsContext
+
+CypherParser.prototype.procedureArguments = function() {
+  var localctx = new ProcedureArgumentsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 174, CypherParser.RULE_procedureArguments)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1373
+    this.match(CypherParser.T__18)
+    this.state = 1375
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 160, this._ctx)
+    if (la_ === 1) {
+      this.state = 1374
+      this.match(CypherParser.SP)
+    }
+    this.state = 1378
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      ((_la & ~0x1f) == 0 &&
+        ((1 << _la) &
+          ((1 << CypherParser.T__2) |
+            (1 << CypherParser.T__12) |
+            (1 << CypherParser.T__13) |
+            (1 << CypherParser.T__16) |
+            (1 << CypherParser.T__18))) !==
+          0) ||
+      (((_la - 34) & ~0x1f) == 0 &&
+        ((1 << (_la - 34)) &
+          ((1 << (CypherParser.T__33 - 34)) |
+            (1 << (CypherParser.CYPHER - 34)) |
+            (1 << (CypherParser.EXPLAIN - 34)) |
+            (1 << (CypherParser.PROFILE - 34)) |
+            (1 << (CypherParser.USING - 34)) |
+            (1 << (CypherParser.PERIODIC - 34)) |
+            (1 << (CypherParser.COMMIT - 34)) |
+            (1 << (CypherParser.UNION - 34)) |
+            (1 << (CypherParser.ALL - 34)) |
+            (1 << (CypherParser.CREATE - 34)) |
+            (1 << (CypherParser.DROP - 34)) |
+            (1 << (CypherParser.INDEX - 34)) |
+            (1 << (CypherParser.ON - 34)))) !==
+          0) ||
+      (((_la - 66) & ~0x1f) == 0 &&
+        ((1 << (_la - 66)) &
+          ((1 << (CypherParser.CONSTRAINT - 66)) |
+            (1 << (CypherParser.ASSERT - 66)) |
+            (1 << (CypherParser.IS - 66)) |
+            (1 << (CypherParser.UNIQUE - 66)) |
+            (1 << (CypherParser.EXISTS - 66)) |
+            (1 << (CypherParser.LOAD - 66)) |
+            (1 << (CypherParser.CSV - 66)) |
+            (1 << (CypherParser.WITH - 66)) |
+            (1 << (CypherParser.HEADERS - 66)) |
+            (1 << (CypherParser.FROM - 66)) |
+            (1 << (CypherParser.AS - 66)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 66)) |
+            (1 << (CypherParser.OPTIONAL - 66)) |
+            (1 << (CypherParser.MATCH - 66)) |
+            (1 << (CypherParser.UNWIND - 66)) |
+            (1 << (CypherParser.MERGE - 66)) |
+            (1 << (CypherParser.SET - 66)) |
+            (1 << (CypherParser.DETACH - 66)) |
+            (1 << (CypherParser.DELETE - 66)) |
+            (1 << (CypherParser.REMOVE - 66)) |
+            (1 << (CypherParser.FOREACH - 66)) |
+            (1 << (CypherParser.IN - 66)) |
+            (1 << (CypherParser.DISTINCT - 66)) |
+            (1 << (CypherParser.RETURN - 66)) |
+            (1 << (CypherParser.ORDER - 66)) |
+            (1 << (CypherParser.BY - 66)) |
+            (1 << (CypherParser.L_SKIP - 66)) |
+            (1 << (CypherParser.LIMIT - 66)) |
+            (1 << (CypherParser.ASCENDING - 66)) |
+            (1 << (CypherParser.ASC - 66)) |
+            (1 << (CypherParser.DESCENDING - 66)) |
+            (1 << (CypherParser.DESC - 66)))) !==
+          0) ||
+      (((_la - 98) & ~0x1f) == 0 &&
+        ((1 << (_la - 98)) &
+          ((1 << (CypherParser.JOIN - 98)) |
+            (1 << (CypherParser.SCAN - 98)) |
+            (1 << (CypherParser.START - 98)) |
+            (1 << (CypherParser.NODE - 98)) |
+            (1 << (CypherParser.RELATIONSHIP - 98)) |
+            (1 << (CypherParser.REL - 98)) |
+            (1 << (CypherParser.WHERE - 98)) |
+            (1 << (CypherParser.SHORTESTPATH - 98)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
+            (1 << (CypherParser.OR - 98)) |
+            (1 << (CypherParser.XOR - 98)) |
+            (1 << (CypherParser.AND - 98)) |
+            (1 << (CypherParser.NOT - 98)) |
+            (1 << (CypherParser.STARTS - 98)) |
+            (1 << (CypherParser.ENDS - 98)) |
+            (1 << (CypherParser.CONTAINS - 98)) |
+            (1 << (CypherParser.NULL - 98)) |
+            (1 << (CypherParser.COUNT - 98)) |
+            (1 << (CypherParser.FILTER - 98)) |
+            (1 << (CypherParser.EXTRACT - 98)) |
+            (1 << (CypherParser.ANY - 98)) |
+            (1 << (CypherParser.NONE - 98)) |
+            (1 << (CypherParser.SINGLE - 98)) |
+            (1 << (CypherParser.TRUE - 98)) |
+            (1 << (CypherParser.FALSE - 98)) |
+            (1 << (CypherParser.REDUCE - 98)) |
+            (1 << (CypherParser.CASE - 98)) |
+            (1 << (CypherParser.ELSE - 98)) |
+            (1 << (CypherParser.END - 98)) |
+            (1 << (CypherParser.WHEN - 98)) |
+            (1 << (CypherParser.THEN - 98)) |
+            (1 << (CypherParser.CALL - 98)))) !==
+          0) ||
+      (((_la - 130) & ~0x1f) == 0 &&
+        ((1 << (_la - 130)) &
+          ((1 << (CypherParser.YIELD - 130)) |
+            (1 << (CypherParser.KEY - 130)) |
+            (1 << (CypherParser.StringLiteral - 130)) |
+            (1 << (CypherParser.HexInteger - 130)) |
+            (1 << (CypherParser.DecimalInteger - 130)) |
+            (1 << (CypherParser.OctalInteger - 130)) |
+            (1 << (CypherParser.HexLetter - 130)) |
+            (1 << (CypherParser.ExponentDecimalReal - 130)) |
+            (1 << (CypherParser.RegularDecimalReal - 130)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 130)) |
+            (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
+          0)
+    ) {
+      this.state = 1377
+      this.expression()
+    }
+
+    this.state = 1390
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 164, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1381
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1380
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1383
+        this.match(CypherParser.T__14)
+        this.state = 1385
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1384
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1387
+        this.expression()
+      }
+      this.state = 1392
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 164, this._ctx)
+    }
+
+    this.state = 1394
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1393
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1396
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProcedureResultsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_procedureResults
+  return this
+}
+
+ProcedureResultsContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ProcedureResultsContext.prototype.constructor = ProcedureResultsContext
+
+ProcedureResultsContext.prototype.YIELD = function() {
+  return this.getToken(CypherParser.YIELD, 0)
+}
+
+ProcedureResultsContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ProcedureResultsContext.prototype.procedureResult = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ProcedureResultContext)
+  } else {
+    return this.getTypedRuleContext(ProcedureResultContext, i)
+  }
+}
+
+ProcedureResultsContext.prototype.where = function() {
+  return this.getTypedRuleContext(WhereContext, 0)
+}
+
+ProcedureResultsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProcedureResults(this)
+  }
+}
+
+ProcedureResultsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProcedureResults(this)
+  }
+}
+
+CypherParser.ProcedureResultsContext = ProcedureResultsContext
+
+CypherParser.prototype.procedureResults = function() {
+  var localctx = new ProcedureResultsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 176, CypherParser.RULE_procedureResults)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1398
+    this.match(CypherParser.YIELD)
+    this.state = 1399
+    this.match(CypherParser.SP)
+    this.state = 1400
+    this.procedureResult()
+    this.state = 1411
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 168, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1402
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1401
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1404
+        this.match(CypherParser.T__14)
+        this.state = 1406
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1405
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1408
+        this.procedureResult()
+      }
+      this.state = 1413
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 168, this._ctx)
+    }
+
+    this.state = 1416
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 169, this._ctx)
+    if (la_ === 1) {
+      this.state = 1414
+      this.match(CypherParser.SP)
+      this.state = 1415
+      this.where()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProcedureResultContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_procedureResult
+  return this
+}
+
+ProcedureResultContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ProcedureResultContext.prototype.constructor = ProcedureResultContext
+
+ProcedureResultContext.prototype.aliasedProcedureResult = function() {
+  return this.getTypedRuleContext(AliasedProcedureResultContext, 0)
+}
+
+ProcedureResultContext.prototype.simpleProcedureResult = function() {
+  return this.getTypedRuleContext(SimpleProcedureResultContext, 0)
+}
+
+ProcedureResultContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProcedureResult(this)
+  }
+}
+
+ProcedureResultContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProcedureResult(this)
+  }
+}
+
+CypherParser.ProcedureResultContext = ProcedureResultContext
+
+CypherParser.prototype.procedureResult = function() {
+  var localctx = new ProcedureResultContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 178, CypherParser.RULE_procedureResult)
+  try {
+    this.state = 1420
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 170, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1418
+        this.aliasedProcedureResult()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1419
+        this.simpleProcedureResult()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AliasedProcedureResultContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_aliasedProcedureResult
+  return this
+}
+
+AliasedProcedureResultContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AliasedProcedureResultContext.prototype.constructor = AliasedProcedureResultContext
+
+AliasedProcedureResultContext.prototype.procedureOutput = function() {
+  return this.getTypedRuleContext(ProcedureOutputContext, 0)
+}
+
+AliasedProcedureResultContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+AliasedProcedureResultContext.prototype.AS = function() {
+  return this.getToken(CypherParser.AS, 0)
+}
+
+AliasedProcedureResultContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+AliasedProcedureResultContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAliasedProcedureResult(this)
+  }
+}
+
+AliasedProcedureResultContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAliasedProcedureResult(this)
+  }
+}
+
+CypherParser.AliasedProcedureResultContext = AliasedProcedureResultContext
+
+CypherParser.prototype.aliasedProcedureResult = function() {
+  var localctx = new AliasedProcedureResultContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 180, CypherParser.RULE_aliasedProcedureResult)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1422
+    this.procedureOutput()
+    this.state = 1423
+    this.match(CypherParser.SP)
+    this.state = 1424
+    this.match(CypherParser.AS)
+    this.state = 1425
+    this.match(CypherParser.SP)
+    this.state = 1426
+    this.variable()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SimpleProcedureResultContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_simpleProcedureResult
+  return this
+}
+
+SimpleProcedureResultContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+SimpleProcedureResultContext.prototype.constructor = SimpleProcedureResultContext
+
+SimpleProcedureResultContext.prototype.procedureOutput = function() {
+  return this.getTypedRuleContext(ProcedureOutputContext, 0)
+}
+
+SimpleProcedureResultContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSimpleProcedureResult(this)
+  }
+}
+
+SimpleProcedureResultContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSimpleProcedureResult(this)
+  }
+}
+
+CypherParser.SimpleProcedureResultContext = SimpleProcedureResultContext
+
+CypherParser.prototype.simpleProcedureResult = function() {
+  var localctx = new SimpleProcedureResultContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 182, CypherParser.RULE_simpleProcedureResult)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1428
+    this.procedureOutput()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProcedureOutputContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_procedureOutput
+  return this
+}
+
+ProcedureOutputContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ProcedureOutputContext.prototype.constructor = ProcedureOutputContext
+
+ProcedureOutputContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+ProcedureOutputContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProcedureOutput(this)
+  }
+}
+
+ProcedureOutputContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProcedureOutput(this)
+  }
+}
+
+CypherParser.ProcedureOutputContext = ProcedureOutputContext
+
+CypherParser.prototype.procedureOutput = function() {
+  var localctx = new ProcedureOutputContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 184, CypherParser.RULE_procedureOutput)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1430
+    this.symbolicName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function OrderContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_order
+  return this
+}
+
+OrderContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+OrderContext.prototype.constructor = OrderContext
+
+OrderContext.prototype.ORDER = function() {
+  return this.getToken(CypherParser.ORDER, 0)
+}
+
+OrderContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+OrderContext.prototype.BY = function() {
+  return this.getToken(CypherParser.BY, 0)
+}
+
+OrderContext.prototype.sortItem = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SortItemContext)
+  } else {
+    return this.getTypedRuleContext(SortItemContext, i)
+  }
+}
+
+OrderContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterOrder(this)
+  }
+}
+
+OrderContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitOrder(this)
+  }
+}
+
+CypherParser.OrderContext = OrderContext
+
+CypherParser.prototype.order = function() {
+  var localctx = new OrderContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 186, CypherParser.RULE_order)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1432
+    this.match(CypherParser.ORDER)
+    this.state = 1433
+    this.match(CypherParser.SP)
+    this.state = 1434
+    this.match(CypherParser.BY)
+    this.state = 1435
+    this.match(CypherParser.SP)
+    this.state = 1436
+    this.sortItem()
+    this.state = 1447
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 173, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1438
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1437
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1440
+        this.match(CypherParser.T__14)
+        this.state = 1442
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1441
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1444
+        this.sortItem()
+      }
+      this.state = 1449
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 173, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SkipContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_skip
+  return this
+}
+
+SkipContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SkipContext.prototype.constructor = SkipContext
+
+SkipContext.prototype.L_SKIP = function() {
+  return this.getToken(CypherParser.L_SKIP, 0)
+}
+
+SkipContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+SkipContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+SkipContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSkip(this)
+  }
+}
+
+SkipContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSkip(this)
+  }
+}
+
+CypherParser.SkipContext = SkipContext
+
+CypherParser.prototype.skip = function() {
+  var localctx = new SkipContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 188, CypherParser.RULE_skip)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1450
+    this.match(CypherParser.L_SKIP)
+    this.state = 1451
+    this.match(CypherParser.SP)
+    this.state = 1452
+    this.expression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LimitContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_limit
+  return this
+}
+
+LimitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+LimitContext.prototype.constructor = LimitContext
+
+LimitContext.prototype.LIMIT = function() {
+  return this.getToken(CypherParser.LIMIT, 0)
+}
+
+LimitContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+LimitContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+LimitContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLimit(this)
+  }
+}
+
+LimitContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLimit(this)
+  }
+}
+
+CypherParser.LimitContext = LimitContext
+
+CypherParser.prototype.limit = function() {
+  var localctx = new LimitContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 190, CypherParser.RULE_limit)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1454
+    this.match(CypherParser.LIMIT)
+    this.state = 1455
+    this.match(CypherParser.SP)
+    this.state = 1456
+    this.expression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SortItemContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_sortItem
+  return this
+}
+
+SortItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+SortItemContext.prototype.constructor = SortItemContext
+
+SortItemContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+SortItemContext.prototype.ASCENDING = function() {
+  return this.getToken(CypherParser.ASCENDING, 0)
+}
+
+SortItemContext.prototype.ASC = function() {
+  return this.getToken(CypherParser.ASC, 0)
+}
+
+SortItemContext.prototype.DESCENDING = function() {
+  return this.getToken(CypherParser.DESCENDING, 0)
+}
+
+SortItemContext.prototype.DESC = function() {
+  return this.getToken(CypherParser.DESC, 0)
+}
+
+SortItemContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+SortItemContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSortItem(this)
+  }
+}
+
+SortItemContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSortItem(this)
+  }
+}
+
+CypherParser.SortItemContext = SortItemContext
+
+CypherParser.prototype.sortItem = function() {
+  var localctx = new SortItemContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 192, CypherParser.RULE_sortItem)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1458
+    this.expression()
+    this.state = 1466
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 176, this._ctx)
+    if (la_ === 1) {
+      this.state = 1460
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1459
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1462
+      _la = this._input.LA(1)
+      if (
+        !(
+          ((_la - 94) & ~0x1f) == 0 &&
+          ((1 << (_la - 94)) &
+            ((1 << (CypherParser.ASCENDING - 94)) |
+              (1 << (CypherParser.ASC - 94)) |
+              (1 << (CypherParser.DESCENDING - 94)) |
+              (1 << (CypherParser.DESC - 94)))) !==
+            0
+        )
+      ) {
+        this._errHandler.recoverInline(this)
+      } else {
+        this._errHandler.reportMatch(this)
+        this.consume()
+      }
+      this.state = 1464
+      this._errHandler.sync(this)
+      var la_ = this._interp.adaptivePredict(this._input, 175, this._ctx)
+      if (la_ === 1) {
+        this.state = 1463
+        this.match(CypherParser.SP)
+      }
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function HintContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_hint
+  return this
+}
+
+HintContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+HintContext.prototype.constructor = HintContext
+
+HintContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+HintContext.prototype.USING = function() {
+  return this.getToken(CypherParser.USING, 0)
+}
+
+HintContext.prototype.INDEX = function() {
+  return this.getToken(CypherParser.INDEX, 0)
+}
+
+HintContext.prototype.variable = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(VariableContext)
+  } else {
+    return this.getTypedRuleContext(VariableContext, i)
+  }
+}
+
+HintContext.prototype.nodeLabel = function() {
+  return this.getTypedRuleContext(NodeLabelContext, 0)
+}
+
+HintContext.prototype.propertyKeys = function() {
+  return this.getTypedRuleContext(PropertyKeysContext, 0)
+}
+
+HintContext.prototype.JOIN = function() {
+  return this.getToken(CypherParser.JOIN, 0)
+}
+
+HintContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+HintContext.prototype.SCAN = function() {
+  return this.getToken(CypherParser.SCAN, 0)
+}
+
+HintContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterHint(this)
+  }
+}
+
+HintContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitHint(this)
+  }
+}
+
+CypherParser.HintContext = HintContext
+
+CypherParser.prototype.hint = function() {
+  var localctx = new HintContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 194, CypherParser.RULE_hint)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1469
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1468
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1517
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 184, this._ctx)
+    switch (la_) {
+      case 1:
+        this.state = 1471
+        this.match(CypherParser.USING)
+        this.state = 1472
+        this.match(CypherParser.SP)
+        this.state = 1473
+        this.match(CypherParser.INDEX)
+        this.state = 1474
+        this.match(CypherParser.SP)
+        this.state = 1475
+        this.variable()
+        this.state = 1476
+        this.nodeLabel()
+        this.state = 1478
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1477
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1480
+        this.match(CypherParser.T__18)
+        this.state = 1482
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1481
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1484
+        this.propertyKeys()
+        this.state = 1486
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1485
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1488
+        this.match(CypherParser.T__19)
+        break
+
+      case 2:
+        this.state = 1490
+        this.match(CypherParser.USING)
+        this.state = 1491
+        this.match(CypherParser.SP)
+        this.state = 1492
+        this.match(CypherParser.JOIN)
+        this.state = 1493
+        this.match(CypherParser.SP)
+        this.state = 1494
+        this.match(CypherParser.ON)
+        this.state = 1495
+        this.match(CypherParser.SP)
+        this.state = 1496
+        this.variable()
+        this.state = 1507
+        this._errHandler.sync(this)
+        var _alt = this._interp.adaptivePredict(this._input, 183, this._ctx)
+        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+          if (_alt === 1) {
+            this.state = 1498
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1497
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1500
+            this.match(CypherParser.T__14)
+            this.state = 1502
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1501
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1504
+            this.variable()
+          }
+          this.state = 1509
+          this._errHandler.sync(this)
+          _alt = this._interp.adaptivePredict(this._input, 183, this._ctx)
+        }
+
+        break
+
+      case 3:
+        this.state = 1510
+        this.match(CypherParser.USING)
+        this.state = 1511
+        this.match(CypherParser.SP)
+        this.state = 1512
+        this.match(CypherParser.SCAN)
+        this.state = 1513
+        this.match(CypherParser.SP)
+        this.state = 1514
+        this.variable()
+        this.state = 1515
+        this.nodeLabel()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function StartClauseContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_startClause
+  return this
+}
+
+StartClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+StartClauseContext.prototype.constructor = StartClauseContext
+
+StartClauseContext.prototype.START = function() {
+  return this.getToken(CypherParser.START, 0)
+}
+
+StartClauseContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+StartClauseContext.prototype.startPoint = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(StartPointContext)
+  } else {
+    return this.getTypedRuleContext(StartPointContext, i)
+  }
+}
+
+StartClauseContext.prototype.where = function() {
+  return this.getTypedRuleContext(WhereContext, 0)
+}
+
+StartClauseContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterStartClause(this)
+  }
+}
+
+StartClauseContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitStartClause(this)
+  }
+}
+
+CypherParser.StartClauseContext = StartClauseContext
+
+CypherParser.prototype.startClause = function() {
+  var localctx = new StartClauseContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 196, CypherParser.RULE_startClause)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1519
+    this.match(CypherParser.START)
+    this.state = 1520
+    this.match(CypherParser.SP)
+    this.state = 1521
+    this.startPoint()
+    this.state = 1532
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 187, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1523
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1522
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1525
+        this.match(CypherParser.T__14)
+        this.state = 1527
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1526
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1529
+        this.startPoint()
+      }
+      this.state = 1534
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 187, this._ctx)
+    }
+
+    this.state = 1536
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.WHERE) {
+      this.state = 1535
+      this.where()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function StartPointContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_startPoint
+  return this
+}
+
+StartPointContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+StartPointContext.prototype.constructor = StartPointContext
+
+StartPointContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+StartPointContext.prototype.lookup = function() {
+  return this.getTypedRuleContext(LookupContext, 0)
+}
+
+StartPointContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+StartPointContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterStartPoint(this)
+  }
+}
+
+StartPointContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitStartPoint(this)
+  }
+}
+
+CypherParser.StartPointContext = StartPointContext
+
+CypherParser.prototype.startPoint = function() {
+  var localctx = new StartPointContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 198, CypherParser.RULE_startPoint)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1538
+    this.variable()
+    this.state = 1540
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1539
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1542
+    this.match(CypherParser.T__11)
+    this.state = 1544
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1543
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1546
+    this.lookup()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LookupContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_lookup
+  return this
+}
+
+LookupContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+LookupContext.prototype.constructor = LookupContext
+
+LookupContext.prototype.nodeLookup = function() {
+  return this.getTypedRuleContext(NodeLookupContext, 0)
+}
+
+LookupContext.prototype.relationshipLookup = function() {
+  return this.getTypedRuleContext(RelationshipLookupContext, 0)
+}
+
+LookupContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLookup(this)
+  }
+}
+
+LookupContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLookup(this)
+  }
+}
+
+CypherParser.LookupContext = LookupContext
+
+CypherParser.prototype.lookup = function() {
+  var localctx = new LookupContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 200, CypherParser.RULE_lookup)
+  try {
+    this.state = 1550
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.NODE:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1548
+        this.nodeLookup()
+        break
+      case CypherParser.RELATIONSHIP:
+      case CypherParser.REL:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1549
+        this.relationshipLookup()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NodeLookupContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_nodeLookup
+  return this
+}
+
+NodeLookupContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+NodeLookupContext.prototype.constructor = NodeLookupContext
+
+NodeLookupContext.prototype.NODE = function() {
+  return this.getToken(CypherParser.NODE, 0)
+}
+
+NodeLookupContext.prototype.identifiedIndexLookup = function() {
+  return this.getTypedRuleContext(IdentifiedIndexLookupContext, 0)
+}
+
+NodeLookupContext.prototype.indexQuery = function() {
+  return this.getTypedRuleContext(IndexQueryContext, 0)
+}
+
+NodeLookupContext.prototype.idLookup = function() {
+  return this.getTypedRuleContext(IdLookupContext, 0)
+}
+
+NodeLookupContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+NodeLookupContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNodeLookup(this)
+  }
+}
+
+NodeLookupContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNodeLookup(this)
+  }
+}
+
+CypherParser.NodeLookupContext = NodeLookupContext
+
+CypherParser.prototype.nodeLookup = function() {
+  var localctx = new NodeLookupContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 202, CypherParser.RULE_nodeLookup)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1552
+    this.match(CypherParser.NODE)
+    this.state = 1554
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1553
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1559
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 193, this._ctx)
+    switch (la_) {
+      case 1:
+        this.state = 1556
+        this.identifiedIndexLookup()
+        break
+
+      case 2:
+        this.state = 1557
+        this.indexQuery()
+        break
+
+      case 3:
+        this.state = 1558
+        this.idLookup()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipLookupContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipLookup
+  return this
+}
+
+RelationshipLookupContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipLookupContext.prototype.constructor = RelationshipLookupContext
+
+RelationshipLookupContext.prototype.RELATIONSHIP = function() {
+  return this.getToken(CypherParser.RELATIONSHIP, 0)
+}
+
+RelationshipLookupContext.prototype.REL = function() {
+  return this.getToken(CypherParser.REL, 0)
+}
+
+RelationshipLookupContext.prototype.identifiedIndexLookup = function() {
+  return this.getTypedRuleContext(IdentifiedIndexLookupContext, 0)
+}
+
+RelationshipLookupContext.prototype.indexQuery = function() {
+  return this.getTypedRuleContext(IndexQueryContext, 0)
+}
+
+RelationshipLookupContext.prototype.idLookup = function() {
+  return this.getTypedRuleContext(IdLookupContext, 0)
+}
+
+RelationshipLookupContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipLookup(this)
+  }
+}
+
+RelationshipLookupContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipLookup(this)
+  }
+}
+
+CypherParser.RelationshipLookupContext = RelationshipLookupContext
+
+CypherParser.prototype.relationshipLookup = function() {
+  var localctx = new RelationshipLookupContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 204, CypherParser.RULE_relationshipLookup)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1561
+    _la = this._input.LA(1)
+    if (!(_la === CypherParser.RELATIONSHIP || _la === CypherParser.REL)) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+    this.state = 1565
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 194, this._ctx)
+    switch (la_) {
+      case 1:
+        this.state = 1562
+        this.identifiedIndexLookup()
+        break
+
+      case 2:
+        this.state = 1563
+        this.indexQuery()
+        break
+
+      case 3:
+        this.state = 1564
+        this.idLookup()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function IdentifiedIndexLookupContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_identifiedIndexLookup
+  return this
+}
+
+IdentifiedIndexLookupContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+IdentifiedIndexLookupContext.prototype.constructor = IdentifiedIndexLookupContext
+
+IdentifiedIndexLookupContext.prototype.symbolicName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SymbolicNameContext)
+  } else {
+    return this.getTypedRuleContext(SymbolicNameContext, i)
+  }
+}
+
+IdentifiedIndexLookupContext.prototype.StringLiteral = function() {
+  return this.getToken(CypherParser.StringLiteral, 0)
+}
+
+IdentifiedIndexLookupContext.prototype.parameter = function() {
+  return this.getTypedRuleContext(ParameterContext, 0)
+}
+
+IdentifiedIndexLookupContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterIdentifiedIndexLookup(this)
+  }
+}
+
+IdentifiedIndexLookupContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitIdentifiedIndexLookup(this)
+  }
+}
+
+CypherParser.IdentifiedIndexLookupContext = IdentifiedIndexLookupContext
+
+CypherParser.prototype.identifiedIndexLookup = function() {
+  var localctx = new IdentifiedIndexLookupContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 206, CypherParser.RULE_identifiedIndexLookup)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1567
+    this.match(CypherParser.T__1)
+    this.state = 1568
+    this.symbolicName()
+    this.state = 1569
+    this.match(CypherParser.T__18)
+    this.state = 1570
+    this.symbolicName()
+    this.state = 1571
+    this.match(CypherParser.T__11)
+    this.state = 1574
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.StringLiteral:
+        this.state = 1572
+        this.match(CypherParser.StringLiteral)
+        break
+      case CypherParser.T__13:
+      case CypherParser.T__33:
+        this.state = 1573
+        this.parameter()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+    this.state = 1576
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function IndexQueryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_indexQuery
+  return this
+}
+
+IndexQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+IndexQueryContext.prototype.constructor = IndexQueryContext
+
+IndexQueryContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+IndexQueryContext.prototype.StringLiteral = function() {
+  return this.getToken(CypherParser.StringLiteral, 0)
+}
+
+IndexQueryContext.prototype.parameter = function() {
+  return this.getTypedRuleContext(ParameterContext, 0)
+}
+
+IndexQueryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterIndexQuery(this)
+  }
+}
+
+IndexQueryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitIndexQuery(this)
+  }
+}
+
+CypherParser.IndexQueryContext = IndexQueryContext
+
+CypherParser.prototype.indexQuery = function() {
+  var localctx = new IndexQueryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 208, CypherParser.RULE_indexQuery)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1578
+    this.match(CypherParser.T__1)
+    this.state = 1579
+    this.symbolicName()
+    this.state = 1580
+    this.match(CypherParser.T__18)
+    this.state = 1583
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.StringLiteral:
+        this.state = 1581
+        this.match(CypherParser.StringLiteral)
+        break
+      case CypherParser.T__13:
+      case CypherParser.T__33:
+        this.state = 1582
+        this.parameter()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+    this.state = 1585
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function IdLookupContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_idLookup
+  return this
+}
+
+IdLookupContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+IdLookupContext.prototype.constructor = IdLookupContext
+
+IdLookupContext.prototype.literalIds = function() {
+  return this.getTypedRuleContext(LiteralIdsContext, 0)
+}
+
+IdLookupContext.prototype.parameter = function() {
+  return this.getTypedRuleContext(ParameterContext, 0)
+}
+
+IdLookupContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterIdLookup(this)
+  }
+}
+
+IdLookupContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitIdLookup(this)
+  }
+}
+
+CypherParser.IdLookupContext = IdLookupContext
+
+CypherParser.prototype.idLookup = function() {
+  var localctx = new IdLookupContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 210, CypherParser.RULE_idLookup)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1587
+    this.match(CypherParser.T__18)
+    this.state = 1591
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.HexInteger:
+      case CypherParser.DecimalInteger:
+      case CypherParser.OctalInteger:
+        this.state = 1588
+        this.literalIds()
+        break
+      case CypherParser.T__13:
+      case CypherParser.T__33:
+        this.state = 1589
+        this.parameter()
+        break
+      case CypherParser.T__22:
+        this.state = 1590
+        this.match(CypherParser.T__22)
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+    this.state = 1593
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LiteralIdsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_literalIds
+  return this
+}
+
+LiteralIdsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+LiteralIdsContext.prototype.constructor = LiteralIdsContext
+
+LiteralIdsContext.prototype.integerLiteral = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(IntegerLiteralContext)
+  } else {
+    return this.getTypedRuleContext(IntegerLiteralContext, i)
+  }
+}
+
+LiteralIdsContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+LiteralIdsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLiteralIds(this)
+  }
+}
+
+LiteralIdsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLiteralIds(this)
+  }
+}
+
+CypherParser.LiteralIdsContext = LiteralIdsContext
+
+CypherParser.prototype.literalIds = function() {
+  var localctx = new LiteralIdsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 212, CypherParser.RULE_literalIds)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1595
+    this.integerLiteral()
+    this.state = 1606
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (_la === CypherParser.T__14 || _la === CypherParser.SP) {
+      this.state = 1597
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1596
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1599
+      this.match(CypherParser.T__14)
+      this.state = 1601
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1600
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1603
+      this.integerLiteral()
+      this.state = 1608
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function WhereContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_where
+  return this
+}
+
+WhereContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+WhereContext.prototype.constructor = WhereContext
+
+WhereContext.prototype.WHERE = function() {
+  return this.getToken(CypherParser.WHERE, 0)
+}
+
+WhereContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+WhereContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+WhereContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterWhere(this)
+  }
+}
+
+WhereContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitWhere(this)
+  }
+}
+
+CypherParser.WhereContext = WhereContext
+
+CypherParser.prototype.where = function() {
+  var localctx = new WhereContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 214, CypherParser.RULE_where)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1609
+    this.match(CypherParser.WHERE)
+    this.state = 1610
+    this.match(CypherParser.SP)
+    this.state = 1611
+    this.expression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PatternContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_pattern
+  return this
+}
+
+PatternContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+PatternContext.prototype.constructor = PatternContext
+
+PatternContext.prototype.patternPart = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PatternPartContext)
+  } else {
+    return this.getTypedRuleContext(PatternPartContext, i)
+  }
+}
+
+PatternContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PatternContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPattern(this)
+  }
+}
+
+PatternContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPattern(this)
+  }
+}
+
+CypherParser.PatternContext = PatternContext
+
+CypherParser.prototype.pattern = function() {
+  var localctx = new PatternContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 216, CypherParser.RULE_pattern)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1613
+    this.patternPart()
+    this.state = 1624
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 203, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1615
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1614
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1617
+        this.match(CypherParser.T__14)
+        this.state = 1619
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1618
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1621
+        this.patternPart()
+      }
+      this.state = 1626
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 203, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PatternPartContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_patternPart
+  return this
+}
+
+PatternPartContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+PatternPartContext.prototype.constructor = PatternPartContext
+
+PatternPartContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+PatternPartContext.prototype.anonymousPatternPart = function() {
+  return this.getTypedRuleContext(AnonymousPatternPartContext, 0)
+}
+
+PatternPartContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PatternPartContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPatternPart(this)
+  }
+}
+
+PatternPartContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPatternPart(this)
+  }
+}
+
+CypherParser.PatternPartContext = PatternPartContext
+
+CypherParser.prototype.patternPart = function() {
+  var localctx = new PatternPartContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 218, CypherParser.RULE_patternPart)
+  var _la = 0 // Token type
+  try {
+    this.state = 1638
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 206, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1627
+        this.variable()
+        this.state = 1629
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1628
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1631
+        this.match(CypherParser.T__11)
+        this.state = 1633
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1632
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1635
+        this.anonymousPatternPart()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1637
+        this.anonymousPatternPart()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AnonymousPatternPartContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_anonymousPatternPart
+  return this
+}
+
+AnonymousPatternPartContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AnonymousPatternPartContext.prototype.constructor = AnonymousPatternPartContext
+
+AnonymousPatternPartContext.prototype.shortestPathPatternFunction = function() {
+  return this.getTypedRuleContext(ShortestPathPatternFunctionContext, 0)
+}
+
+AnonymousPatternPartContext.prototype.patternElement = function() {
+  return this.getTypedRuleContext(PatternElementContext, 0)
+}
+
+AnonymousPatternPartContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAnonymousPatternPart(this)
+  }
+}
+
+AnonymousPatternPartContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAnonymousPatternPart(this)
+  }
+}
+
+CypherParser.AnonymousPatternPartContext = AnonymousPatternPartContext
+
+CypherParser.prototype.anonymousPatternPart = function() {
+  var localctx = new AnonymousPatternPartContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 220, CypherParser.RULE_anonymousPatternPart)
+  try {
+    this.state = 1642
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.SHORTESTPATH:
+      case CypherParser.ALLSHORTESTPATHS:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1640
+        this.shortestPathPatternFunction()
+        break
+      case CypherParser.T__18:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1641
+        this.patternElement()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PatternElementContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_patternElement
+  return this
+}
+
+PatternElementContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PatternElementContext.prototype.constructor = PatternElementContext
+
+PatternElementContext.prototype.nodePattern = function() {
+  return this.getTypedRuleContext(NodePatternContext, 0)
+}
+
+PatternElementContext.prototype.patternElementChain = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PatternElementChainContext)
+  } else {
+    return this.getTypedRuleContext(PatternElementChainContext, i)
+  }
+}
+
+PatternElementContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PatternElementContext.prototype.patternElement = function() {
+  return this.getTypedRuleContext(PatternElementContext, 0)
+}
+
+PatternElementContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPatternElement(this)
+  }
+}
+
+PatternElementContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPatternElement(this)
+  }
+}
+
+CypherParser.PatternElementContext = PatternElementContext
+
+CypherParser.prototype.patternElement = function() {
+  var localctx = new PatternElementContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 222, CypherParser.RULE_patternElement)
+  var _la = 0 // Token type
+  try {
+    this.state = 1658
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 210, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1644
+        this.nodePattern()
+        this.state = 1651
+        this._errHandler.sync(this)
+        var _alt = this._interp.adaptivePredict(this._input, 209, this._ctx)
+        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+          if (_alt === 1) {
+            this.state = 1646
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1645
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1648
+            this.patternElementChain()
+          }
+          this.state = 1653
+          this._errHandler.sync(this)
+          _alt = this._interp.adaptivePredict(this._input, 209, this._ctx)
+        }
+
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1654
+        this.match(CypherParser.T__18)
+        this.state = 1655
+        this.patternElement()
+        this.state = 1656
+        this.match(CypherParser.T__19)
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NodePatternContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_nodePattern
+  return this
+}
+
+NodePatternContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+NodePatternContext.prototype.constructor = NodePatternContext
+
+NodePatternContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+NodePatternContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+NodePatternContext.prototype.nodeLabels = function() {
+  return this.getTypedRuleContext(NodeLabelsContext, 0)
+}
+
+NodePatternContext.prototype.properties = function() {
+  return this.getTypedRuleContext(PropertiesContext, 0)
+}
+
+NodePatternContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNodePattern(this)
+  }
+}
+
+NodePatternContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNodePattern(this)
+  }
+}
+
+CypherParser.NodePatternContext = NodePatternContext
+
+CypherParser.prototype.nodePattern = function() {
+  var localctx = new NodePatternContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 224, CypherParser.RULE_nodePattern)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1660
+    this.match(CypherParser.T__18)
+    this.state = 1662
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1661
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1668
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      (((_la - 54) & ~0x1f) == 0 &&
+        ((1 << (_la - 54)) &
+          ((1 << (CypherParser.CYPHER - 54)) |
+            (1 << (CypherParser.EXPLAIN - 54)) |
+            (1 << (CypherParser.PROFILE - 54)) |
+            (1 << (CypherParser.USING - 54)) |
+            (1 << (CypherParser.PERIODIC - 54)) |
+            (1 << (CypherParser.COMMIT - 54)) |
+            (1 << (CypherParser.UNION - 54)) |
+            (1 << (CypherParser.ALL - 54)) |
+            (1 << (CypherParser.CREATE - 54)) |
+            (1 << (CypherParser.DROP - 54)) |
+            (1 << (CypherParser.INDEX - 54)) |
+            (1 << (CypherParser.ON - 54)) |
+            (1 << (CypherParser.CONSTRAINT - 54)) |
+            (1 << (CypherParser.ASSERT - 54)) |
+            (1 << (CypherParser.IS - 54)) |
+            (1 << (CypherParser.UNIQUE - 54)) |
+            (1 << (CypherParser.EXISTS - 54)) |
+            (1 << (CypherParser.LOAD - 54)) |
+            (1 << (CypherParser.CSV - 54)) |
+            (1 << (CypherParser.WITH - 54)) |
+            (1 << (CypherParser.HEADERS - 54)) |
+            (1 << (CypherParser.FROM - 54)) |
+            (1 << (CypherParser.AS - 54)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
+            (1 << (CypherParser.OPTIONAL - 54)) |
+            (1 << (CypherParser.MATCH - 54)) |
+            (1 << (CypherParser.UNWIND - 54)) |
+            (1 << (CypherParser.MERGE - 54)) |
+            (1 << (CypherParser.SET - 54)) |
+            (1 << (CypherParser.DETACH - 54)) |
+            (1 << (CypherParser.DELETE - 54)) |
+            (1 << (CypherParser.REMOVE - 54)))) !==
+          0) ||
+      (((_la - 86) & ~0x1f) == 0 &&
+        ((1 << (_la - 86)) &
+          ((1 << (CypherParser.FOREACH - 86)) |
+            (1 << (CypherParser.IN - 86)) |
+            (1 << (CypherParser.DISTINCT - 86)) |
+            (1 << (CypherParser.RETURN - 86)) |
+            (1 << (CypherParser.ORDER - 86)) |
+            (1 << (CypherParser.BY - 86)) |
+            (1 << (CypherParser.L_SKIP - 86)) |
+            (1 << (CypherParser.LIMIT - 86)) |
+            (1 << (CypherParser.ASCENDING - 86)) |
+            (1 << (CypherParser.ASC - 86)) |
+            (1 << (CypherParser.DESCENDING - 86)) |
+            (1 << (CypherParser.DESC - 86)) |
+            (1 << (CypherParser.JOIN - 86)) |
+            (1 << (CypherParser.SCAN - 86)) |
+            (1 << (CypherParser.START - 86)) |
+            (1 << (CypherParser.NODE - 86)) |
+            (1 << (CypherParser.RELATIONSHIP - 86)) |
+            (1 << (CypherParser.REL - 86)) |
+            (1 << (CypherParser.WHERE - 86)) |
+            (1 << (CypherParser.SHORTESTPATH - 86)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
+            (1 << (CypherParser.OR - 86)) |
+            (1 << (CypherParser.XOR - 86)) |
+            (1 << (CypherParser.AND - 86)) |
+            (1 << (CypherParser.NOT - 86)) |
+            (1 << (CypherParser.STARTS - 86)) |
+            (1 << (CypherParser.ENDS - 86)) |
+            (1 << (CypherParser.CONTAINS - 86)) |
+            (1 << (CypherParser.NULL - 86)) |
+            (1 << (CypherParser.COUNT - 86)) |
+            (1 << (CypherParser.FILTER - 86)) |
+            (1 << (CypherParser.EXTRACT - 86)))) !==
+          0) ||
+      (((_la - 118) & ~0x1f) == 0 &&
+        ((1 << (_la - 118)) &
+          ((1 << (CypherParser.ANY - 118)) |
+            (1 << (CypherParser.NONE - 118)) |
+            (1 << (CypherParser.SINGLE - 118)) |
+            (1 << (CypherParser.TRUE - 118)) |
+            (1 << (CypherParser.FALSE - 118)) |
+            (1 << (CypherParser.REDUCE - 118)) |
+            (1 << (CypherParser.CASE - 118)) |
+            (1 << (CypherParser.ELSE - 118)) |
+            (1 << (CypherParser.END - 118)) |
+            (1 << (CypherParser.WHEN - 118)) |
+            (1 << (CypherParser.THEN - 118)) |
+            (1 << (CypherParser.CALL - 118)) |
+            (1 << (CypherParser.YIELD - 118)) |
+            (1 << (CypherParser.KEY - 118)) |
+            (1 << (CypherParser.HexLetter - 118)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
+          0) ||
+      _la === CypherParser.EscapedSymbolicName
+    ) {
+      this.state = 1664
+      this.variable()
+      this.state = 1666
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1665
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 1674
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__1) {
+      this.state = 1670
+      this.nodeLabels()
+      this.state = 1672
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1671
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 1680
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__13 || _la === CypherParser.T__33) {
+      this.state = 1676
+      this.properties()
+      this.state = 1678
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1677
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 1682
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PatternElementChainContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_patternElementChain
+  return this
+}
+
+PatternElementChainContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PatternElementChainContext.prototype.constructor = PatternElementChainContext
+
+PatternElementChainContext.prototype.relationshipPattern = function() {
+  return this.getTypedRuleContext(RelationshipPatternContext, 0)
+}
+
+PatternElementChainContext.prototype.nodePattern = function() {
+  return this.getTypedRuleContext(NodePatternContext, 0)
+}
+
+PatternElementChainContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+PatternElementChainContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPatternElementChain(this)
+  }
+}
+
+PatternElementChainContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPatternElementChain(this)
+  }
+}
+
+CypherParser.PatternElementChainContext = PatternElementChainContext
+
+CypherParser.prototype.patternElementChain = function() {
+  var localctx = new PatternElementChainContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 226, CypherParser.RULE_patternElementChain)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1684
+    this.relationshipPattern()
+    this.state = 1686
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1685
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1688
+    this.nodePattern()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipPatternContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipPattern
+  return this
+}
+
+RelationshipPatternContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipPatternContext.prototype.constructor = RelationshipPatternContext
+
+RelationshipPatternContext.prototype.relationshipPatternStart = function() {
+  return this.getTypedRuleContext(RelationshipPatternStartContext, 0)
+}
+
+RelationshipPatternContext.prototype.relationshipPatternEnd = function() {
+  return this.getTypedRuleContext(RelationshipPatternEndContext, 0)
+}
+
+RelationshipPatternContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RelationshipPatternContext.prototype.relationshipDetail = function() {
+  return this.getTypedRuleContext(RelationshipDetailContext, 0)
+}
+
+RelationshipPatternContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipPattern(this)
+  }
+}
+
+RelationshipPatternContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipPattern(this)
+  }
+}
+
+CypherParser.RelationshipPatternContext = RelationshipPatternContext
+
+CypherParser.prototype.relationshipPattern = function() {
+  var localctx = new RelationshipPatternContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 228, CypherParser.RULE_relationshipPattern)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1690
+    this.relationshipPatternStart()
+    this.state = 1692
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 219, this._ctx)
+    if (la_ === 1) {
+      this.state = 1691
+      this.match(CypherParser.SP)
+    }
+    this.state = 1695
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__16) {
+      this.state = 1694
+      this.relationshipDetail()
+    }
+
+    this.state = 1698
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1697
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1700
+    this.relationshipPatternEnd()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipPatternStartContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipPatternStart
+  return this
+}
+
+RelationshipPatternStartContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipPatternStartContext.prototype.constructor = RelationshipPatternStartContext
+
+RelationshipPatternStartContext.prototype.leftArrowHead = function() {
+  return this.getTypedRuleContext(LeftArrowHeadContext, 0)
+}
+
+RelationshipPatternStartContext.prototype.dash = function() {
+  return this.getTypedRuleContext(DashContext, 0)
+}
+
+RelationshipPatternStartContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+RelationshipPatternStartContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipPatternStart(this)
+  }
+}
+
+RelationshipPatternStartContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipPatternStart(this)
+  }
+}
+
+CypherParser.RelationshipPatternStartContext = RelationshipPatternStartContext
+
+CypherParser.prototype.relationshipPatternStart = function() {
+  var localctx = new RelationshipPatternStartContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 230, CypherParser.RULE_relationshipPatternStart)
+  var _la = 0 // Token type
+  try {
+    this.state = 1709
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.T__29:
+      case CypherParser.T__34:
+      case CypherParser.T__35:
+      case CypherParser.T__36:
+      case CypherParser.T__37:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1702
+        this.leftArrowHead()
+        this.state = 1704
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1703
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1706
+        this.dash()
+        break
+      case CypherParser.T__2:
+      case CypherParser.T__42:
+      case CypherParser.T__43:
+      case CypherParser.T__44:
+      case CypherParser.T__45:
+      case CypherParser.T__46:
+      case CypherParser.T__47:
+      case CypherParser.T__48:
+      case CypherParser.T__49:
+      case CypherParser.T__50:
+      case CypherParser.T__51:
+      case CypherParser.T__52:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1708
+        this.dash()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipPatternEndContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipPatternEnd
+  return this
+}
+
+RelationshipPatternEndContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipPatternEndContext.prototype.constructor = RelationshipPatternEndContext
+
+RelationshipPatternEndContext.prototype.dash = function() {
+  return this.getTypedRuleContext(DashContext, 0)
+}
+
+RelationshipPatternEndContext.prototype.rightArrowHead = function() {
+  return this.getTypedRuleContext(RightArrowHeadContext, 0)
+}
+
+RelationshipPatternEndContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+RelationshipPatternEndContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipPatternEnd(this)
+  }
+}
+
+RelationshipPatternEndContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipPatternEnd(this)
+  }
+}
+
+CypherParser.RelationshipPatternEndContext = RelationshipPatternEndContext
+
+CypherParser.prototype.relationshipPatternEnd = function() {
+  var localctx = new RelationshipPatternEndContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 232, CypherParser.RULE_relationshipPatternEnd)
+  var _la = 0 // Token type
+  try {
+    this.state = 1718
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 225, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1711
+        this.dash()
+        this.state = 1713
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1712
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1715
+        this.rightArrowHead()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1717
+        this.dash()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipDetailContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipDetail
+  return this
+}
+
+RelationshipDetailContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipDetailContext.prototype.constructor = RelationshipDetailContext
+
+RelationshipDetailContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RelationshipDetailContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+RelationshipDetailContext.prototype.relationshipTypes = function() {
+  return this.getTypedRuleContext(RelationshipTypesContext, 0)
+}
+
+RelationshipDetailContext.prototype.rangeLiteral = function() {
+  return this.getTypedRuleContext(RangeLiteralContext, 0)
+}
+
+RelationshipDetailContext.prototype.properties = function() {
+  return this.getTypedRuleContext(PropertiesContext, 0)
+}
+
+RelationshipDetailContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipDetail(this)
+  }
+}
+
+RelationshipDetailContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipDetail(this)
+  }
+}
+
+CypherParser.RelationshipDetailContext = RelationshipDetailContext
+
+CypherParser.prototype.relationshipDetail = function() {
+  var localctx = new RelationshipDetailContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 234, CypherParser.RULE_relationshipDetail)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1720
+    this.match(CypherParser.T__16)
+    this.state = 1722
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1721
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1728
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      (((_la - 54) & ~0x1f) == 0 &&
+        ((1 << (_la - 54)) &
+          ((1 << (CypherParser.CYPHER - 54)) |
+            (1 << (CypherParser.EXPLAIN - 54)) |
+            (1 << (CypherParser.PROFILE - 54)) |
+            (1 << (CypherParser.USING - 54)) |
+            (1 << (CypherParser.PERIODIC - 54)) |
+            (1 << (CypherParser.COMMIT - 54)) |
+            (1 << (CypherParser.UNION - 54)) |
+            (1 << (CypherParser.ALL - 54)) |
+            (1 << (CypherParser.CREATE - 54)) |
+            (1 << (CypherParser.DROP - 54)) |
+            (1 << (CypherParser.INDEX - 54)) |
+            (1 << (CypherParser.ON - 54)) |
+            (1 << (CypherParser.CONSTRAINT - 54)) |
+            (1 << (CypherParser.ASSERT - 54)) |
+            (1 << (CypherParser.IS - 54)) |
+            (1 << (CypherParser.UNIQUE - 54)) |
+            (1 << (CypherParser.EXISTS - 54)) |
+            (1 << (CypherParser.LOAD - 54)) |
+            (1 << (CypherParser.CSV - 54)) |
+            (1 << (CypherParser.WITH - 54)) |
+            (1 << (CypherParser.HEADERS - 54)) |
+            (1 << (CypherParser.FROM - 54)) |
+            (1 << (CypherParser.AS - 54)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
+            (1 << (CypherParser.OPTIONAL - 54)) |
+            (1 << (CypherParser.MATCH - 54)) |
+            (1 << (CypherParser.UNWIND - 54)) |
+            (1 << (CypherParser.MERGE - 54)) |
+            (1 << (CypherParser.SET - 54)) |
+            (1 << (CypherParser.DETACH - 54)) |
+            (1 << (CypherParser.DELETE - 54)) |
+            (1 << (CypherParser.REMOVE - 54)))) !==
+          0) ||
+      (((_la - 86) & ~0x1f) == 0 &&
+        ((1 << (_la - 86)) &
+          ((1 << (CypherParser.FOREACH - 86)) |
+            (1 << (CypherParser.IN - 86)) |
+            (1 << (CypherParser.DISTINCT - 86)) |
+            (1 << (CypherParser.RETURN - 86)) |
+            (1 << (CypherParser.ORDER - 86)) |
+            (1 << (CypherParser.BY - 86)) |
+            (1 << (CypherParser.L_SKIP - 86)) |
+            (1 << (CypherParser.LIMIT - 86)) |
+            (1 << (CypherParser.ASCENDING - 86)) |
+            (1 << (CypherParser.ASC - 86)) |
+            (1 << (CypherParser.DESCENDING - 86)) |
+            (1 << (CypherParser.DESC - 86)) |
+            (1 << (CypherParser.JOIN - 86)) |
+            (1 << (CypherParser.SCAN - 86)) |
+            (1 << (CypherParser.START - 86)) |
+            (1 << (CypherParser.NODE - 86)) |
+            (1 << (CypherParser.RELATIONSHIP - 86)) |
+            (1 << (CypherParser.REL - 86)) |
+            (1 << (CypherParser.WHERE - 86)) |
+            (1 << (CypherParser.SHORTESTPATH - 86)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
+            (1 << (CypherParser.OR - 86)) |
+            (1 << (CypherParser.XOR - 86)) |
+            (1 << (CypherParser.AND - 86)) |
+            (1 << (CypherParser.NOT - 86)) |
+            (1 << (CypherParser.STARTS - 86)) |
+            (1 << (CypherParser.ENDS - 86)) |
+            (1 << (CypherParser.CONTAINS - 86)) |
+            (1 << (CypherParser.NULL - 86)) |
+            (1 << (CypherParser.COUNT - 86)) |
+            (1 << (CypherParser.FILTER - 86)) |
+            (1 << (CypherParser.EXTRACT - 86)))) !==
+          0) ||
+      (((_la - 118) & ~0x1f) == 0 &&
+        ((1 << (_la - 118)) &
+          ((1 << (CypherParser.ANY - 118)) |
+            (1 << (CypherParser.NONE - 118)) |
+            (1 << (CypherParser.SINGLE - 118)) |
+            (1 << (CypherParser.TRUE - 118)) |
+            (1 << (CypherParser.FALSE - 118)) |
+            (1 << (CypherParser.REDUCE - 118)) |
+            (1 << (CypherParser.CASE - 118)) |
+            (1 << (CypherParser.ELSE - 118)) |
+            (1 << (CypherParser.END - 118)) |
+            (1 << (CypherParser.WHEN - 118)) |
+            (1 << (CypherParser.THEN - 118)) |
+            (1 << (CypherParser.CALL - 118)) |
+            (1 << (CypherParser.YIELD - 118)) |
+            (1 << (CypherParser.KEY - 118)) |
+            (1 << (CypherParser.HexLetter - 118)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
+          0) ||
+      _la === CypherParser.EscapedSymbolicName
+    ) {
+      this.state = 1724
+      this.variable()
+      this.state = 1726
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1725
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 1734
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__1) {
+      this.state = 1730
+      this.relationshipTypes()
+      this.state = 1732
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1731
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 1737
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__22) {
+      this.state = 1736
+      this.rangeLiteral()
+    }
+
+    this.state = 1743
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__13 || _la === CypherParser.T__33) {
+      this.state = 1739
+      this.properties()
+      this.state = 1741
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1740
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 1745
+    this.match(CypherParser.T__17)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertiesContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_properties
+  return this
+}
+
+PropertiesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+PropertiesContext.prototype.constructor = PropertiesContext
+
+PropertiesContext.prototype.mapLiteral = function() {
+  return this.getTypedRuleContext(MapLiteralContext, 0)
+}
+
+PropertiesContext.prototype.parameter = function() {
+  return this.getTypedRuleContext(ParameterContext, 0)
+}
+
+PropertiesContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProperties(this)
+  }
+}
+
+PropertiesContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProperties(this)
+  }
+}
+
+CypherParser.PropertiesContext = PropertiesContext
+
+CypherParser.prototype.properties = function() {
+  var localctx = new PropertiesContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 236, CypherParser.RULE_properties)
+  try {
+    this.state = 1749
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 234, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 1747
+        this.mapLiteral()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 1748
+        this.parameter()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelTypeContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relType
+  return this
+}
+
+RelTypeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+RelTypeContext.prototype.constructor = RelTypeContext
+
+RelTypeContext.prototype.relTypeName = function() {
+  return this.getTypedRuleContext(RelTypeNameContext, 0)
+}
+
+RelTypeContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+RelTypeContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelType(this)
+  }
+}
+
+RelTypeContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelType(this)
+  }
+}
+
+CypherParser.RelTypeContext = RelTypeContext
+
+CypherParser.prototype.relType = function() {
+  var localctx = new RelTypeContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 238, CypherParser.RULE_relType)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1751
+    this.match(CypherParser.T__1)
+    this.state = 1753
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1752
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1755
+    this.relTypeName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipTypesContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipTypes
+  return this
+}
+
+RelationshipTypesContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipTypesContext.prototype.constructor = RelationshipTypesContext
+
+RelationshipTypesContext.prototype.relationshipType = function() {
+  return this.getTypedRuleContext(RelationshipTypeContext, 0)
+}
+
+RelationshipTypesContext.prototype.relationshipTypeOptionalColon = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(RelationshipTypeOptionalColonContext)
+  } else {
+    return this.getTypedRuleContext(RelationshipTypeOptionalColonContext, i)
+  }
+}
+
+RelationshipTypesContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RelationshipTypesContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipTypes(this)
+  }
+}
+
+RelationshipTypesContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipTypes(this)
+  }
+}
+
+CypherParser.RelationshipTypesContext = RelationshipTypesContext
+
+CypherParser.prototype.relationshipTypes = function() {
+  var localctx = new RelationshipTypesContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 240, CypherParser.RULE_relationshipTypes)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1757
+    this.relationshipType()
+    this.state = 1765
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 237, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1759
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1758
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1761
+        this.match(CypherParser.T__21)
+        this.state = 1762
+        this.relationshipTypeOptionalColon()
+      }
+      this.state = 1767
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 237, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipTypeContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipType
+  return this
+}
+
+RelationshipTypeContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipTypeContext.prototype.constructor = RelationshipTypeContext
+
+RelationshipTypeContext.prototype.relTypeName = function() {
+  return this.getTypedRuleContext(RelTypeNameContext, 0)
+}
+
+RelationshipTypeContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipType(this)
+  }
+}
+
+RelationshipTypeContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipType(this)
+  }
+}
+
+CypherParser.RelationshipTypeContext = RelationshipTypeContext
+
+CypherParser.prototype.relationshipType = function() {
+  var localctx = new RelationshipTypeContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 242, CypherParser.RULE_relationshipType)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1768
+    this.match(CypherParser.T__1)
+    this.state = 1769
+    this.relTypeName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipTypeOptionalColonContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipTypeOptionalColon
+  return this
+}
+
+RelationshipTypeOptionalColonContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipTypeOptionalColonContext.prototype.constructor = RelationshipTypeOptionalColonContext
+
+RelationshipTypeOptionalColonContext.prototype.relTypeName = function() {
+  return this.getTypedRuleContext(RelTypeNameContext, 0)
+}
+
+RelationshipTypeOptionalColonContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipTypeOptionalColon(this)
+  }
+}
+
+RelationshipTypeOptionalColonContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipTypeOptionalColon(this)
+  }
+}
+
+CypherParser.RelationshipTypeOptionalColonContext = RelationshipTypeOptionalColonContext
+
+CypherParser.prototype.relationshipTypeOptionalColon = function() {
+  var localctx = new RelationshipTypeOptionalColonContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 244, CypherParser.RULE_relationshipTypeOptionalColon)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1772
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__1) {
+      this.state = 1771
+      this.match(CypherParser.T__1)
+    }
+
+    this.state = 1774
+    this.relTypeName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NodeLabelsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_nodeLabels
+  return this
+}
+
+NodeLabelsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+NodeLabelsContext.prototype.constructor = NodeLabelsContext
+
+NodeLabelsContext.prototype.nodeLabel = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(NodeLabelContext)
+  } else {
+    return this.getTypedRuleContext(NodeLabelContext, i)
+  }
+}
+
+NodeLabelsContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+NodeLabelsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNodeLabels(this)
+  }
+}
+
+NodeLabelsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNodeLabels(this)
+  }
+}
+
+CypherParser.NodeLabelsContext = NodeLabelsContext
+
+CypherParser.prototype.nodeLabels = function() {
+  var localctx = new NodeLabelsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 246, CypherParser.RULE_nodeLabels)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1776
+    this.nodeLabel()
+    this.state = 1783
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 240, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1778
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1777
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1780
+        this.nodeLabel()
+      }
+      this.state = 1785
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 240, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NodeLabelContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_nodeLabel
+  return this
+}
+
+NodeLabelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+NodeLabelContext.prototype.constructor = NodeLabelContext
+
+NodeLabelContext.prototype.labelName = function() {
+  return this.getTypedRuleContext(LabelNameContext, 0)
+}
+
+NodeLabelContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNodeLabel(this)
+  }
+}
+
+NodeLabelContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNodeLabel(this)
+  }
+}
+
+CypherParser.NodeLabelContext = NodeLabelContext
+
+CypherParser.prototype.nodeLabel = function() {
+  var localctx = new NodeLabelContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 248, CypherParser.RULE_nodeLabel)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1786
+    this.match(CypherParser.T__1)
+    this.state = 1787
+    this.labelName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RangeLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_rangeLiteral
+  return this
+}
+
+RangeLiteralContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RangeLiteralContext.prototype.constructor = RangeLiteralContext
+
+RangeLiteralContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RangeLiteralContext.prototype.integerLiteral = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(IntegerLiteralContext)
+  } else {
+    return this.getTypedRuleContext(IntegerLiteralContext, i)
+  }
+}
+
+RangeLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRangeLiteral(this)
+  }
+}
+
+RangeLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRangeLiteral(this)
+  }
+}
+
+CypherParser.RangeLiteralContext = RangeLiteralContext
+
+CypherParser.prototype.rangeLiteral = function() {
+  var localctx = new RangeLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 250, CypherParser.RULE_rangeLiteral)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1789
+    this.match(CypherParser.T__22)
+    this.state = 1791
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 1790
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 1797
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      ((_la - 135) & ~0x1f) == 0 &&
+      ((1 << (_la - 135)) &
+        ((1 << (CypherParser.HexInteger - 135)) |
+          (1 << (CypherParser.DecimalInteger - 135)) |
+          (1 << (CypherParser.OctalInteger - 135)))) !==
+        0
+    ) {
+      this.state = 1793
+      this.integerLiteral()
+      this.state = 1795
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1794
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 1809
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.T__23) {
+      this.state = 1799
+      this.match(CypherParser.T__23)
+      this.state = 1801
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1800
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1807
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (
+        ((_la - 135) & ~0x1f) == 0 &&
+        ((1 << (_la - 135)) &
+          ((1 << (CypherParser.HexInteger - 135)) |
+            (1 << (CypherParser.DecimalInteger - 135)) |
+            (1 << (CypherParser.OctalInteger - 135)))) !==
+          0
+      ) {
+        this.state = 1803
+        this.integerLiteral()
+        this.state = 1805
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1804
+          this.match(CypherParser.SP)
+        }
+      }
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LabelNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_labelName
+  return this
+}
+
+LabelNameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+LabelNameContext.prototype.constructor = LabelNameContext
+
+LabelNameContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+LabelNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLabelName(this)
+  }
+}
+
+LabelNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLabelName(this)
+  }
+}
+
+CypherParser.LabelNameContext = LabelNameContext
+
+CypherParser.prototype.labelName = function() {
+  var localctx = new LabelNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 252, CypherParser.RULE_labelName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1811
+    this.symbolicName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelTypeNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relTypeName
+  return this
+}
+
+RelTypeNameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+RelTypeNameContext.prototype.constructor = RelTypeNameContext
+
+RelTypeNameContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+RelTypeNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelTypeName(this)
+  }
+}
+
+RelTypeNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelTypeName(this)
+  }
+}
+
+CypherParser.RelTypeNameContext = RelTypeNameContext
+
+CypherParser.prototype.relTypeName = function() {
+  var localctx = new RelTypeNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 254, CypherParser.RULE_relTypeName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1813
+    this.symbolicName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_expression
+  return this
+}
+
+ExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ExpressionContext.prototype.constructor = ExpressionContext
+
+ExpressionContext.prototype.orExpression = function() {
+  return this.getTypedRuleContext(OrExpressionContext, 0)
+}
+
+ExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterExpression(this)
+  }
+}
+
+ExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitExpression(this)
+  }
+}
+
+CypherParser.ExpressionContext = ExpressionContext
+
+CypherParser.prototype.expression = function() {
+  var localctx = new ExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 256, CypherParser.RULE_expression)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1815
+    this.orExpression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function OrExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_orExpression
+  return this
+}
+
+OrExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+OrExpressionContext.prototype.constructor = OrExpressionContext
+
+OrExpressionContext.prototype.xorExpression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(XorExpressionContext)
+  } else {
+    return this.getTypedRuleContext(XorExpressionContext, i)
+  }
+}
+
+OrExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+OrExpressionContext.prototype.OR = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.OR)
+  } else {
+    return this.getToken(CypherParser.OR, i)
+  }
+}
+
+OrExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterOrExpression(this)
+  }
+}
+
+OrExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitOrExpression(this)
+  }
+}
+
+CypherParser.OrExpressionContext = OrExpressionContext
+
+CypherParser.prototype.orExpression = function() {
+  var localctx = new OrExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 258, CypherParser.RULE_orExpression)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1817
+    this.xorExpression()
+    this.state = 1824
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 248, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1818
+        this.match(CypherParser.SP)
+        this.state = 1819
+        this.match(CypherParser.OR)
+        this.state = 1820
+        this.match(CypherParser.SP)
+        this.state = 1821
+        this.xorExpression()
+      }
+      this.state = 1826
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 248, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function XorExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_xorExpression
+  return this
+}
+
+XorExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+XorExpressionContext.prototype.constructor = XorExpressionContext
+
+XorExpressionContext.prototype.andExpression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(AndExpressionContext)
+  } else {
+    return this.getTypedRuleContext(AndExpressionContext, i)
+  }
+}
+
+XorExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+XorExpressionContext.prototype.XOR = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.XOR)
+  } else {
+    return this.getToken(CypherParser.XOR, i)
+  }
+}
+
+XorExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterXorExpression(this)
+  }
+}
+
+XorExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitXorExpression(this)
+  }
+}
+
+CypherParser.XorExpressionContext = XorExpressionContext
+
+CypherParser.prototype.xorExpression = function() {
+  var localctx = new XorExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 260, CypherParser.RULE_xorExpression)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1827
+    this.andExpression()
+    this.state = 1834
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 249, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1828
+        this.match(CypherParser.SP)
+        this.state = 1829
+        this.match(CypherParser.XOR)
+        this.state = 1830
+        this.match(CypherParser.SP)
+        this.state = 1831
+        this.andExpression()
+      }
+      this.state = 1836
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 249, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AndExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_andExpression
+  return this
+}
+
+AndExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AndExpressionContext.prototype.constructor = AndExpressionContext
+
+AndExpressionContext.prototype.notExpression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(NotExpressionContext)
+  } else {
+    return this.getTypedRuleContext(NotExpressionContext, i)
+  }
+}
+
+AndExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+AndExpressionContext.prototype.AND = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.AND)
+  } else {
+    return this.getToken(CypherParser.AND, i)
+  }
+}
+
+AndExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAndExpression(this)
+  }
+}
+
+AndExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAndExpression(this)
+  }
+}
+
+CypherParser.AndExpressionContext = AndExpressionContext
+
+CypherParser.prototype.andExpression = function() {
+  var localctx = new AndExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 262, CypherParser.RULE_andExpression)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1837
+    this.notExpression()
+    this.state = 1844
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 250, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1838
+        this.match(CypherParser.SP)
+        this.state = 1839
+        this.match(CypherParser.AND)
+        this.state = 1840
+        this.match(CypherParser.SP)
+        this.state = 1841
+        this.notExpression()
+      }
+      this.state = 1846
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 250, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NotExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_notExpression
+  return this
+}
+
+NotExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+NotExpressionContext.prototype.constructor = NotExpressionContext
+
+NotExpressionContext.prototype.comparisonExpression = function() {
+  return this.getTypedRuleContext(ComparisonExpressionContext, 0)
+}
+
+NotExpressionContext.prototype.NOT = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.NOT)
+  } else {
+    return this.getToken(CypherParser.NOT, i)
+  }
+}
+
+NotExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+NotExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNotExpression(this)
+  }
+}
+
+NotExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNotExpression(this)
+  }
+}
+
+CypherParser.NotExpressionContext = NotExpressionContext
+
+CypherParser.prototype.notExpression = function() {
+  var localctx = new NotExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 264, CypherParser.RULE_notExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1853
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 252, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1847
+        this.match(CypherParser.NOT)
+        this.state = 1849
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1848
+          this.match(CypherParser.SP)
+        }
+      }
+      this.state = 1855
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 252, this._ctx)
+    }
+
+    this.state = 1856
+    this.comparisonExpression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ComparisonExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_comparisonExpression
+  return this
+}
+
+ComparisonExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ComparisonExpressionContext.prototype.constructor = ComparisonExpressionContext
+
+ComparisonExpressionContext.prototype.addOrSubtractExpression = function() {
+  return this.getTypedRuleContext(AddOrSubtractExpressionContext, 0)
+}
+
+ComparisonExpressionContext.prototype.partialComparisonExpression = function(
+  i
+) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PartialComparisonExpressionContext)
+  } else {
+    return this.getTypedRuleContext(PartialComparisonExpressionContext, i)
+  }
+}
+
+ComparisonExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ComparisonExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterComparisonExpression(this)
+  }
+}
+
+ComparisonExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitComparisonExpression(this)
+  }
+}
+
+CypherParser.ComparisonExpressionContext = ComparisonExpressionContext
+
+CypherParser.prototype.comparisonExpression = function() {
+  var localctx = new ComparisonExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 266, CypherParser.RULE_comparisonExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1858
+    this.addOrSubtractExpression()
+    this.state = 1865
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 254, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1860
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1859
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1862
+        this.partialComparisonExpression()
+      }
+      this.state = 1867
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 254, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AddOrSubtractExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_addOrSubtractExpression
+  return this
+}
+
+AddOrSubtractExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AddOrSubtractExpressionContext.prototype.constructor = AddOrSubtractExpressionContext
+
+AddOrSubtractExpressionContext.prototype.multiplyDivideModuloExpression = function(
+  i
+) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(MultiplyDivideModuloExpressionContext)
+  } else {
+    return this.getTypedRuleContext(MultiplyDivideModuloExpressionContext, i)
+  }
+}
+
+AddOrSubtractExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+AddOrSubtractExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAddOrSubtractExpression(this)
+  }
+}
+
+AddOrSubtractExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAddOrSubtractExpression(this)
+  }
+}
+
+CypherParser.AddOrSubtractExpressionContext = AddOrSubtractExpressionContext
+
+CypherParser.prototype.addOrSubtractExpression = function() {
+  var localctx = new AddOrSubtractExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 268, CypherParser.RULE_addOrSubtractExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1868
+    this.multiplyDivideModuloExpression()
+    this.state = 1887
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 260, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1885
+        this._errHandler.sync(this)
+        var la_ = this._interp.adaptivePredict(this._input, 259, this._ctx)
+        switch (la_) {
+          case 1:
+            this.state = 1870
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1869
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1872
+            this.match(CypherParser.T__12)
+            this.state = 1874
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1873
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1876
+            this.multiplyDivideModuloExpression()
+            break
+
+          case 2:
+            this.state = 1878
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1877
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1880
+            this.match(CypherParser.T__2)
+            this.state = 1882
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1881
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1884
+            this.multiplyDivideModuloExpression()
+            break
+        }
+      }
+      this.state = 1889
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 260, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function MultiplyDivideModuloExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_multiplyDivideModuloExpression
+  return this
+}
+
+MultiplyDivideModuloExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+MultiplyDivideModuloExpressionContext.prototype.constructor = MultiplyDivideModuloExpressionContext
+
+MultiplyDivideModuloExpressionContext.prototype.powerOfExpression = function(
+  i
+) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PowerOfExpressionContext)
+  } else {
+    return this.getTypedRuleContext(PowerOfExpressionContext, i)
+  }
+}
+
+MultiplyDivideModuloExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+MultiplyDivideModuloExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterMultiplyDivideModuloExpression(this)
+  }
+}
+
+MultiplyDivideModuloExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitMultiplyDivideModuloExpression(this)
+  }
+}
+
+CypherParser.MultiplyDivideModuloExpressionContext = MultiplyDivideModuloExpressionContext
+
+CypherParser.prototype.multiplyDivideModuloExpression = function() {
+  var localctx = new MultiplyDivideModuloExpressionContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    270,
+    CypherParser.RULE_multiplyDivideModuloExpression
+  )
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1890
+    this.powerOfExpression()
+    this.state = 1917
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 268, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1915
+        this._errHandler.sync(this)
+        var la_ = this._interp.adaptivePredict(this._input, 267, this._ctx)
+        switch (la_) {
+          case 1:
+            this.state = 1892
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1891
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1894
+            this.match(CypherParser.T__22)
+            this.state = 1896
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1895
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1898
+            this.powerOfExpression()
+            break
+
+          case 2:
+            this.state = 1900
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1899
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1902
+            this.match(CypherParser.T__5)
+            this.state = 1904
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1903
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1906
+            this.powerOfExpression()
+            break
+
+          case 3:
+            this.state = 1908
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1907
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1910
+            this.match(CypherParser.T__24)
+            this.state = 1912
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1911
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1914
+            this.powerOfExpression()
+            break
+        }
+      }
+      this.state = 1919
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 268, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PowerOfExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_powerOfExpression
+  return this
+}
+
+PowerOfExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PowerOfExpressionContext.prototype.constructor = PowerOfExpressionContext
+
+PowerOfExpressionContext.prototype.unaryAddOrSubtractExpression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(UnaryAddOrSubtractExpressionContext)
+  } else {
+    return this.getTypedRuleContext(UnaryAddOrSubtractExpressionContext, i)
+  }
+}
+
+PowerOfExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PowerOfExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPowerOfExpression(this)
+  }
+}
+
+PowerOfExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPowerOfExpression(this)
+  }
+}
+
+CypherParser.PowerOfExpressionContext = PowerOfExpressionContext
+
+CypherParser.prototype.powerOfExpression = function() {
+  var localctx = new PowerOfExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 272, CypherParser.RULE_powerOfExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1920
+    this.unaryAddOrSubtractExpression()
+    this.state = 1931
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 271, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1922
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1921
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1924
+        this.match(CypherParser.T__25)
+        this.state = 1926
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 1925
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 1928
+        this.unaryAddOrSubtractExpression()
+      }
+      this.state = 1933
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 271, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function UnaryAddOrSubtractExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_unaryAddOrSubtractExpression
+  return this
+}
+
+UnaryAddOrSubtractExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+UnaryAddOrSubtractExpressionContext.prototype.constructor = UnaryAddOrSubtractExpressionContext
+
+UnaryAddOrSubtractExpressionContext.prototype.stringListNullOperatorExpression = function() {
+  return this.getTypedRuleContext(StringListNullOperatorExpressionContext, 0)
+}
+
+UnaryAddOrSubtractExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+UnaryAddOrSubtractExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterUnaryAddOrSubtractExpression(this)
+  }
+}
+
+UnaryAddOrSubtractExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitUnaryAddOrSubtractExpression(this)
+  }
+}
+
+CypherParser.UnaryAddOrSubtractExpressionContext = UnaryAddOrSubtractExpressionContext
+
+CypherParser.prototype.unaryAddOrSubtractExpression = function() {
+  var localctx = new UnaryAddOrSubtractExpressionContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 274, CypherParser.RULE_unaryAddOrSubtractExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1940
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    while (_la === CypherParser.T__2 || _la === CypherParser.T__12) {
+      this.state = 1934
+      _la = this._input.LA(1)
+      if (!(_la === CypherParser.T__2 || _la === CypherParser.T__12)) {
+        this._errHandler.recoverInline(this)
+      } else {
+        this._errHandler.reportMatch(this)
+        this.consume()
+      }
+      this.state = 1936
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 1935
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 1942
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+    }
+    this.state = 1943
+    this.stringListNullOperatorExpression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function StringListNullOperatorExpressionContext(
+  parser,
+  parent,
+  invokingState
+) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_stringListNullOperatorExpression
+  return this
+}
+
+StringListNullOperatorExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+StringListNullOperatorExpressionContext.prototype.constructor = StringListNullOperatorExpressionContext
+
+StringListNullOperatorExpressionContext.prototype.propertyOrLabelsExpression = function(
+  i
+) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PropertyOrLabelsExpressionContext)
+  } else {
+    return this.getTypedRuleContext(PropertyOrLabelsExpressionContext, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.IS = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.IS)
+  } else {
+    return this.getToken(CypherParser.IS, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.NULL = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.NULL)
+  } else {
+    return this.getToken(CypherParser.NULL, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.NOT = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.NOT)
+  } else {
+    return this.getToken(CypherParser.NOT, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.IN = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.IN)
+  } else {
+    return this.getToken(CypherParser.IN, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.STARTS = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.STARTS)
+  } else {
+    return this.getToken(CypherParser.STARTS, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.WITH = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.WITH)
+  } else {
+    return this.getToken(CypherParser.WITH, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.ENDS = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.ENDS)
+  } else {
+    return this.getToken(CypherParser.ENDS, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.CONTAINS = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.CONTAINS)
+  } else {
+    return this.getToken(CypherParser.CONTAINS, i)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.enterRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.enterStringListNullOperatorExpression(this)
+  }
+}
+
+StringListNullOperatorExpressionContext.prototype.exitRule = function(
+  listener
+) {
+  if (listener instanceof CypherListener) {
+    listener.exitStringListNullOperatorExpression(this)
+  }
+}
+
+CypherParser.StringListNullOperatorExpressionContext = StringListNullOperatorExpressionContext
+
+CypherParser.prototype.stringListNullOperatorExpression = function() {
+  var localctx = new StringListNullOperatorExpressionContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(
+    localctx,
+    276,
+    CypherParser.RULE_stringListNullOperatorExpression
+  )
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 1945
+    this.propertyOrLabelsExpression()
+    this.state = 1999
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 282, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 1997
+        this._errHandler.sync(this)
+        var la_ = this._interp.adaptivePredict(this._input, 281, this._ctx)
+        switch (la_) {
+          case 1:
+            this.state = 1947
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1946
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1949
+            this.match(CypherParser.T__16)
+            this.state = 1950
+            this.expression()
+            this.state = 1951
+            this.match(CypherParser.T__17)
+            break
+
+          case 2:
+            this.state = 1954
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1953
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1956
+            this.match(CypherParser.T__16)
+            this.state = 1958
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (
+              ((_la & ~0x1f) == 0 &&
+                ((1 << _la) &
+                  ((1 << CypherParser.T__2) |
+                    (1 << CypherParser.T__12) |
+                    (1 << CypherParser.T__13) |
+                    (1 << CypherParser.T__16) |
+                    (1 << CypherParser.T__18))) !==
+                  0) ||
+              (((_la - 34) & ~0x1f) == 0 &&
+                ((1 << (_la - 34)) &
+                  ((1 << (CypherParser.T__33 - 34)) |
+                    (1 << (CypherParser.CYPHER - 34)) |
+                    (1 << (CypherParser.EXPLAIN - 34)) |
+                    (1 << (CypherParser.PROFILE - 34)) |
+                    (1 << (CypherParser.USING - 34)) |
+                    (1 << (CypherParser.PERIODIC - 34)) |
+                    (1 << (CypherParser.COMMIT - 34)) |
+                    (1 << (CypherParser.UNION - 34)) |
+                    (1 << (CypherParser.ALL - 34)) |
+                    (1 << (CypherParser.CREATE - 34)) |
+                    (1 << (CypherParser.DROP - 34)) |
+                    (1 << (CypherParser.INDEX - 34)) |
+                    (1 << (CypherParser.ON - 34)))) !==
+                  0) ||
+              (((_la - 66) & ~0x1f) == 0 &&
+                ((1 << (_la - 66)) &
+                  ((1 << (CypherParser.CONSTRAINT - 66)) |
+                    (1 << (CypherParser.ASSERT - 66)) |
+                    (1 << (CypherParser.IS - 66)) |
+                    (1 << (CypherParser.UNIQUE - 66)) |
+                    (1 << (CypherParser.EXISTS - 66)) |
+                    (1 << (CypherParser.LOAD - 66)) |
+                    (1 << (CypherParser.CSV - 66)) |
+                    (1 << (CypherParser.WITH - 66)) |
+                    (1 << (CypherParser.HEADERS - 66)) |
+                    (1 << (CypherParser.FROM - 66)) |
+                    (1 << (CypherParser.AS - 66)) |
+                    (1 << (CypherParser.FIELDTERMINATOR - 66)) |
+                    (1 << (CypherParser.OPTIONAL - 66)) |
+                    (1 << (CypherParser.MATCH - 66)) |
+                    (1 << (CypherParser.UNWIND - 66)) |
+                    (1 << (CypherParser.MERGE - 66)) |
+                    (1 << (CypherParser.SET - 66)) |
+                    (1 << (CypherParser.DETACH - 66)) |
+                    (1 << (CypherParser.DELETE - 66)) |
+                    (1 << (CypherParser.REMOVE - 66)) |
+                    (1 << (CypherParser.FOREACH - 66)) |
+                    (1 << (CypherParser.IN - 66)) |
+                    (1 << (CypherParser.DISTINCT - 66)) |
+                    (1 << (CypherParser.RETURN - 66)) |
+                    (1 << (CypherParser.ORDER - 66)) |
+                    (1 << (CypherParser.BY - 66)) |
+                    (1 << (CypherParser.L_SKIP - 66)) |
+                    (1 << (CypherParser.LIMIT - 66)) |
+                    (1 << (CypherParser.ASCENDING - 66)) |
+                    (1 << (CypherParser.ASC - 66)) |
+                    (1 << (CypherParser.DESCENDING - 66)) |
+                    (1 << (CypherParser.DESC - 66)))) !==
+                  0) ||
+              (((_la - 98) & ~0x1f) == 0 &&
+                ((1 << (_la - 98)) &
+                  ((1 << (CypherParser.JOIN - 98)) |
+                    (1 << (CypherParser.SCAN - 98)) |
+                    (1 << (CypherParser.START - 98)) |
+                    (1 << (CypherParser.NODE - 98)) |
+                    (1 << (CypherParser.RELATIONSHIP - 98)) |
+                    (1 << (CypherParser.REL - 98)) |
+                    (1 << (CypherParser.WHERE - 98)) |
+                    (1 << (CypherParser.SHORTESTPATH - 98)) |
+                    (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
+                    (1 << (CypherParser.OR - 98)) |
+                    (1 << (CypherParser.XOR - 98)) |
+                    (1 << (CypherParser.AND - 98)) |
+                    (1 << (CypherParser.NOT - 98)) |
+                    (1 << (CypherParser.STARTS - 98)) |
+                    (1 << (CypherParser.ENDS - 98)) |
+                    (1 << (CypherParser.CONTAINS - 98)) |
+                    (1 << (CypherParser.NULL - 98)) |
+                    (1 << (CypherParser.COUNT - 98)) |
+                    (1 << (CypherParser.FILTER - 98)) |
+                    (1 << (CypherParser.EXTRACT - 98)) |
+                    (1 << (CypherParser.ANY - 98)) |
+                    (1 << (CypherParser.NONE - 98)) |
+                    (1 << (CypherParser.SINGLE - 98)) |
+                    (1 << (CypherParser.TRUE - 98)) |
+                    (1 << (CypherParser.FALSE - 98)) |
+                    (1 << (CypherParser.REDUCE - 98)) |
+                    (1 << (CypherParser.CASE - 98)) |
+                    (1 << (CypherParser.ELSE - 98)) |
+                    (1 << (CypherParser.END - 98)) |
+                    (1 << (CypherParser.WHEN - 98)) |
+                    (1 << (CypherParser.THEN - 98)) |
+                    (1 << (CypherParser.CALL - 98)))) !==
+                  0) ||
+              (((_la - 130) & ~0x1f) == 0 &&
+                ((1 << (_la - 130)) &
+                  ((1 << (CypherParser.YIELD - 130)) |
+                    (1 << (CypherParser.KEY - 130)) |
+                    (1 << (CypherParser.StringLiteral - 130)) |
+                    (1 << (CypherParser.HexInteger - 130)) |
+                    (1 << (CypherParser.DecimalInteger - 130)) |
+                    (1 << (CypherParser.OctalInteger - 130)) |
+                    (1 << (CypherParser.HexLetter - 130)) |
+                    (1 << (CypherParser.ExponentDecimalReal - 130)) |
+                    (1 << (CypherParser.RegularDecimalReal - 130)) |
+                    (1 << (CypherParser.UnescapedSymbolicName - 130)) |
+                    (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
+                  0)
+            ) {
+              this.state = 1957
+              this.expression()
+            }
+
+            this.state = 1960
+            this.match(CypherParser.T__23)
+            this.state = 1962
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (
+              ((_la & ~0x1f) == 0 &&
+                ((1 << _la) &
+                  ((1 << CypherParser.T__2) |
+                    (1 << CypherParser.T__12) |
+                    (1 << CypherParser.T__13) |
+                    (1 << CypherParser.T__16) |
+                    (1 << CypherParser.T__18))) !==
+                  0) ||
+              (((_la - 34) & ~0x1f) == 0 &&
+                ((1 << (_la - 34)) &
+                  ((1 << (CypherParser.T__33 - 34)) |
+                    (1 << (CypherParser.CYPHER - 34)) |
+                    (1 << (CypherParser.EXPLAIN - 34)) |
+                    (1 << (CypherParser.PROFILE - 34)) |
+                    (1 << (CypherParser.USING - 34)) |
+                    (1 << (CypherParser.PERIODIC - 34)) |
+                    (1 << (CypherParser.COMMIT - 34)) |
+                    (1 << (CypherParser.UNION - 34)) |
+                    (1 << (CypherParser.ALL - 34)) |
+                    (1 << (CypherParser.CREATE - 34)) |
+                    (1 << (CypherParser.DROP - 34)) |
+                    (1 << (CypherParser.INDEX - 34)) |
+                    (1 << (CypherParser.ON - 34)))) !==
+                  0) ||
+              (((_la - 66) & ~0x1f) == 0 &&
+                ((1 << (_la - 66)) &
+                  ((1 << (CypherParser.CONSTRAINT - 66)) |
+                    (1 << (CypherParser.ASSERT - 66)) |
+                    (1 << (CypherParser.IS - 66)) |
+                    (1 << (CypherParser.UNIQUE - 66)) |
+                    (1 << (CypherParser.EXISTS - 66)) |
+                    (1 << (CypherParser.LOAD - 66)) |
+                    (1 << (CypherParser.CSV - 66)) |
+                    (1 << (CypherParser.WITH - 66)) |
+                    (1 << (CypherParser.HEADERS - 66)) |
+                    (1 << (CypherParser.FROM - 66)) |
+                    (1 << (CypherParser.AS - 66)) |
+                    (1 << (CypherParser.FIELDTERMINATOR - 66)) |
+                    (1 << (CypherParser.OPTIONAL - 66)) |
+                    (1 << (CypherParser.MATCH - 66)) |
+                    (1 << (CypherParser.UNWIND - 66)) |
+                    (1 << (CypherParser.MERGE - 66)) |
+                    (1 << (CypherParser.SET - 66)) |
+                    (1 << (CypherParser.DETACH - 66)) |
+                    (1 << (CypherParser.DELETE - 66)) |
+                    (1 << (CypherParser.REMOVE - 66)) |
+                    (1 << (CypherParser.FOREACH - 66)) |
+                    (1 << (CypherParser.IN - 66)) |
+                    (1 << (CypherParser.DISTINCT - 66)) |
+                    (1 << (CypherParser.RETURN - 66)) |
+                    (1 << (CypherParser.ORDER - 66)) |
+                    (1 << (CypherParser.BY - 66)) |
+                    (1 << (CypherParser.L_SKIP - 66)) |
+                    (1 << (CypherParser.LIMIT - 66)) |
+                    (1 << (CypherParser.ASCENDING - 66)) |
+                    (1 << (CypherParser.ASC - 66)) |
+                    (1 << (CypherParser.DESCENDING - 66)) |
+                    (1 << (CypherParser.DESC - 66)))) !==
+                  0) ||
+              (((_la - 98) & ~0x1f) == 0 &&
+                ((1 << (_la - 98)) &
+                  ((1 << (CypherParser.JOIN - 98)) |
+                    (1 << (CypherParser.SCAN - 98)) |
+                    (1 << (CypherParser.START - 98)) |
+                    (1 << (CypherParser.NODE - 98)) |
+                    (1 << (CypherParser.RELATIONSHIP - 98)) |
+                    (1 << (CypherParser.REL - 98)) |
+                    (1 << (CypherParser.WHERE - 98)) |
+                    (1 << (CypherParser.SHORTESTPATH - 98)) |
+                    (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
+                    (1 << (CypherParser.OR - 98)) |
+                    (1 << (CypherParser.XOR - 98)) |
+                    (1 << (CypherParser.AND - 98)) |
+                    (1 << (CypherParser.NOT - 98)) |
+                    (1 << (CypherParser.STARTS - 98)) |
+                    (1 << (CypherParser.ENDS - 98)) |
+                    (1 << (CypherParser.CONTAINS - 98)) |
+                    (1 << (CypherParser.NULL - 98)) |
+                    (1 << (CypherParser.COUNT - 98)) |
+                    (1 << (CypherParser.FILTER - 98)) |
+                    (1 << (CypherParser.EXTRACT - 98)) |
+                    (1 << (CypherParser.ANY - 98)) |
+                    (1 << (CypherParser.NONE - 98)) |
+                    (1 << (CypherParser.SINGLE - 98)) |
+                    (1 << (CypherParser.TRUE - 98)) |
+                    (1 << (CypherParser.FALSE - 98)) |
+                    (1 << (CypherParser.REDUCE - 98)) |
+                    (1 << (CypherParser.CASE - 98)) |
+                    (1 << (CypherParser.ELSE - 98)) |
+                    (1 << (CypherParser.END - 98)) |
+                    (1 << (CypherParser.WHEN - 98)) |
+                    (1 << (CypherParser.THEN - 98)) |
+                    (1 << (CypherParser.CALL - 98)))) !==
+                  0) ||
+              (((_la - 130) & ~0x1f) == 0 &&
+                ((1 << (_la - 130)) &
+                  ((1 << (CypherParser.YIELD - 130)) |
+                    (1 << (CypherParser.KEY - 130)) |
+                    (1 << (CypherParser.StringLiteral - 130)) |
+                    (1 << (CypherParser.HexInteger - 130)) |
+                    (1 << (CypherParser.DecimalInteger - 130)) |
+                    (1 << (CypherParser.OctalInteger - 130)) |
+                    (1 << (CypherParser.HexLetter - 130)) |
+                    (1 << (CypherParser.ExponentDecimalReal - 130)) |
+                    (1 << (CypherParser.RegularDecimalReal - 130)) |
+                    (1 << (CypherParser.UnescapedSymbolicName - 130)) |
+                    (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
+                  0)
+            ) {
+              this.state = 1961
+              this.expression()
+            }
+
+            this.state = 1964
+            this.match(CypherParser.T__17)
+            break
+
+          case 3:
+            this.state = 1981
+            this._errHandler.sync(this)
+            var la_ = this._interp.adaptivePredict(this._input, 279, this._ctx)
+            switch (la_) {
+              case 1:
+                this.state = 1966
+                this._errHandler.sync(this)
+                _la = this._input.LA(1)
+                if (_la === CypherParser.SP) {
+                  this.state = 1965
+                  this.match(CypherParser.SP)
+                }
+
+                this.state = 1968
+                this.match(CypherParser.T__26)
+                break
+
+              case 2:
+                this.state = 1969
+                this.match(CypherParser.SP)
+                this.state = 1970
+                this.match(CypherParser.IN)
+                break
+
+              case 3:
+                this.state = 1971
+                this.match(CypherParser.SP)
+                this.state = 1972
+                this.match(CypherParser.STARTS)
+                this.state = 1973
+                this.match(CypherParser.SP)
+                this.state = 1974
+                this.match(CypherParser.WITH)
+                break
+
+              case 4:
+                this.state = 1975
+                this.match(CypherParser.SP)
+                this.state = 1976
+                this.match(CypherParser.ENDS)
+                this.state = 1977
+                this.match(CypherParser.SP)
+                this.state = 1978
+                this.match(CypherParser.WITH)
+                break
+
+              case 5:
+                this.state = 1979
+                this.match(CypherParser.SP)
+                this.state = 1980
+                this.match(CypherParser.CONTAINS)
+                break
+            }
+            this.state = 1984
+            this._errHandler.sync(this)
+            _la = this._input.LA(1)
+            if (_la === CypherParser.SP) {
+              this.state = 1983
+              this.match(CypherParser.SP)
+            }
+
+            this.state = 1986
+            this.propertyOrLabelsExpression()
+            break
+
+          case 4:
+            this.state = 1987
+            this.match(CypherParser.SP)
+            this.state = 1988
+            this.match(CypherParser.IS)
+            this.state = 1989
+            this.match(CypherParser.SP)
+            this.state = 1990
+            this.match(CypherParser.NULL)
+            break
+
+          case 5:
+            this.state = 1991
+            this.match(CypherParser.SP)
+            this.state = 1992
+            this.match(CypherParser.IS)
+            this.state = 1993
+            this.match(CypherParser.SP)
+            this.state = 1994
+            this.match(CypherParser.NOT)
+            this.state = 1995
+            this.match(CypherParser.SP)
+            this.state = 1996
+            this.match(CypherParser.NULL)
+            break
+        }
+      }
+      this.state = 2001
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 282, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertyOrLabelsExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_propertyOrLabelsExpression
+  return this
+}
+
+PropertyOrLabelsExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PropertyOrLabelsExpressionContext.prototype.constructor = PropertyOrLabelsExpressionContext
+
+PropertyOrLabelsExpressionContext.prototype.atom = function() {
+  return this.getTypedRuleContext(AtomContext, 0)
+}
+
+PropertyOrLabelsExpressionContext.prototype.propertyLookup = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PropertyLookupContext)
+  } else {
+    return this.getTypedRuleContext(PropertyLookupContext, i)
+  }
+}
+
+PropertyOrLabelsExpressionContext.prototype.nodeLabels = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(NodeLabelsContext)
+  } else {
+    return this.getTypedRuleContext(NodeLabelsContext, i)
+  }
+}
+
+PropertyOrLabelsExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PropertyOrLabelsExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPropertyOrLabelsExpression(this)
+  }
+}
+
+PropertyOrLabelsExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPropertyOrLabelsExpression(this)
+  }
+}
+
+CypherParser.PropertyOrLabelsExpressionContext = PropertyOrLabelsExpressionContext
+
+CypherParser.prototype.propertyOrLabelsExpression = function() {
+  var localctx = new PropertyOrLabelsExpressionContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 278, CypherParser.RULE_propertyOrLabelsExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2002
+    this.atom()
+    this.state = 2012
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 285, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 2004
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2003
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2008
+        this._errHandler.sync(this)
+        switch (this._input.LA(1)) {
+          case CypherParser.T__6:
+            this.state = 2006
+            this.propertyLookup()
+            break
+          case CypherParser.T__1:
+            this.state = 2007
+            this.nodeLabels()
+            break
+          default:
+            throw new antlr4.error.NoViableAltException(this)
+        }
+      }
+      this.state = 2014
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 285, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function FilterFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_filterFunction
+  return this
+}
+
+FilterFunctionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+FilterFunctionContext.prototype.constructor = FilterFunctionContext
+
+FilterFunctionContext.prototype.filterFunctionName = function() {
+  return this.getTypedRuleContext(FilterFunctionNameContext, 0)
+}
+
+FilterFunctionContext.prototype.filterExpression = function() {
+  return this.getTypedRuleContext(FilterExpressionContext, 0)
+}
+
+FilterFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+FilterFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterFilterFunction(this)
+  }
+}
+
+FilterFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitFilterFunction(this)
+  }
+}
+
+CypherParser.FilterFunctionContext = FilterFunctionContext
+
+CypherParser.prototype.filterFunction = function() {
+  var localctx = new FilterFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 280, CypherParser.RULE_filterFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2015
+    this.filterFunctionName()
+    this.state = 2017
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2016
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2019
+    this.match(CypherParser.T__18)
+    this.state = 2021
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2020
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2023
+    this.filterExpression()
+    this.state = 2025
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2024
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2027
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function FilterFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_filterFunctionName
+  return this
+}
+
+FilterFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+FilterFunctionNameContext.prototype.constructor = FilterFunctionNameContext
+
+FilterFunctionNameContext.prototype.FILTER = function() {
+  return this.getToken(CypherParser.FILTER, 0)
+}
+
+FilterFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterFilterFunctionName(this)
+  }
+}
+
+FilterFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitFilterFunctionName(this)
+  }
+}
+
+CypherParser.FilterFunctionNameContext = FilterFunctionNameContext
+
+CypherParser.prototype.filterFunctionName = function() {
+  var localctx = new FilterFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 282, CypherParser.RULE_filterFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2029
+    this.match(CypherParser.FILTER)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ExistsFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_existsFunction
+  return this
+}
+
+ExistsFunctionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ExistsFunctionContext.prototype.constructor = ExistsFunctionContext
+
+ExistsFunctionContext.prototype.existsFunctionName = function() {
+  return this.getTypedRuleContext(ExistsFunctionNameContext, 0)
+}
+
+ExistsFunctionContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+ExistsFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ExistsFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterExistsFunction(this)
+  }
+}
+
+ExistsFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitExistsFunction(this)
+  }
+}
+
+CypherParser.ExistsFunctionContext = ExistsFunctionContext
+
+CypherParser.prototype.existsFunction = function() {
+  var localctx = new ExistsFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 284, CypherParser.RULE_existsFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2031
+    this.existsFunctionName()
+    this.state = 2033
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2032
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2035
+    this.match(CypherParser.T__18)
+    this.state = 2037
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2036
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2039
+    this.expression()
+    this.state = 2041
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2040
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2043
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ExistsFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_existsFunctionName
+  return this
+}
+
+ExistsFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ExistsFunctionNameContext.prototype.constructor = ExistsFunctionNameContext
+
+ExistsFunctionNameContext.prototype.EXISTS = function() {
+  return this.getToken(CypherParser.EXISTS, 0)
+}
+
+ExistsFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterExistsFunctionName(this)
+  }
+}
+
+ExistsFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitExistsFunctionName(this)
+  }
+}
+
+CypherParser.ExistsFunctionNameContext = ExistsFunctionNameContext
+
+CypherParser.prototype.existsFunctionName = function() {
+  var localctx = new ExistsFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 286, CypherParser.RULE_existsFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2045
+    this.match(CypherParser.EXISTS)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AllFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_allFunction
+  return this
+}
+
+AllFunctionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+AllFunctionContext.prototype.constructor = AllFunctionContext
+
+AllFunctionContext.prototype.allFunctionName = function() {
+  return this.getTypedRuleContext(AllFunctionNameContext, 0)
+}
+
+AllFunctionContext.prototype.filterExpression = function() {
+  return this.getTypedRuleContext(FilterExpressionContext, 0)
+}
+
+AllFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+AllFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAllFunction(this)
+  }
+}
+
+AllFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAllFunction(this)
+  }
+}
+
+CypherParser.AllFunctionContext = AllFunctionContext
+
+CypherParser.prototype.allFunction = function() {
+  var localctx = new AllFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 288, CypherParser.RULE_allFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2047
+    this.allFunctionName()
+    this.state = 2049
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2048
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2051
+    this.match(CypherParser.T__18)
+    this.state = 2053
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2052
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2055
+    this.filterExpression()
+    this.state = 2057
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2056
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2059
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AllFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_allFunctionName
+  return this
+}
+
+AllFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AllFunctionNameContext.prototype.constructor = AllFunctionNameContext
+
+AllFunctionNameContext.prototype.ALL = function() {
+  return this.getToken(CypherParser.ALL, 0)
+}
+
+AllFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAllFunctionName(this)
+  }
+}
+
+AllFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAllFunctionName(this)
+  }
+}
+
+CypherParser.AllFunctionNameContext = AllFunctionNameContext
+
+CypherParser.prototype.allFunctionName = function() {
+  var localctx = new AllFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 290, CypherParser.RULE_allFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2061
+    this.match(CypherParser.ALL)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AnyFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_anyFunction
+  return this
+}
+
+AnyFunctionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+AnyFunctionContext.prototype.constructor = AnyFunctionContext
+
+AnyFunctionContext.prototype.anyFunctionName = function() {
+  return this.getTypedRuleContext(AnyFunctionNameContext, 0)
+}
+
+AnyFunctionContext.prototype.filterExpression = function() {
+  return this.getTypedRuleContext(FilterExpressionContext, 0)
+}
+
+AnyFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+AnyFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAnyFunction(this)
+  }
+}
+
+AnyFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAnyFunction(this)
+  }
+}
+
+CypherParser.AnyFunctionContext = AnyFunctionContext
+
+CypherParser.prototype.anyFunction = function() {
+  var localctx = new AnyFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 292, CypherParser.RULE_anyFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2063
+    this.anyFunctionName()
+    this.state = 2065
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2064
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2067
+    this.match(CypherParser.T__18)
+    this.state = 2069
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2068
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2071
+    this.filterExpression()
+    this.state = 2073
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2072
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2075
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AnyFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_anyFunctionName
+  return this
+}
+
+AnyFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AnyFunctionNameContext.prototype.constructor = AnyFunctionNameContext
+
+AnyFunctionNameContext.prototype.ANY = function() {
+  return this.getToken(CypherParser.ANY, 0)
+}
+
+AnyFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAnyFunctionName(this)
+  }
+}
+
+AnyFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAnyFunctionName(this)
+  }
+}
+
+CypherParser.AnyFunctionNameContext = AnyFunctionNameContext
+
+CypherParser.prototype.anyFunctionName = function() {
+  var localctx = new AnyFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 294, CypherParser.RULE_anyFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2077
+    this.match(CypherParser.ANY)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NoneFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_noneFunction
+  return this
+}
+
+NoneFunctionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+NoneFunctionContext.prototype.constructor = NoneFunctionContext
+
+NoneFunctionContext.prototype.noneFunctionName = function() {
+  return this.getTypedRuleContext(NoneFunctionNameContext, 0)
+}
+
+NoneFunctionContext.prototype.filterExpression = function() {
+  return this.getTypedRuleContext(FilterExpressionContext, 0)
+}
+
+NoneFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+NoneFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNoneFunction(this)
+  }
+}
+
+NoneFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNoneFunction(this)
+  }
+}
+
+CypherParser.NoneFunctionContext = NoneFunctionContext
+
+CypherParser.prototype.noneFunction = function() {
+  var localctx = new NoneFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 296, CypherParser.RULE_noneFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2079
+    this.noneFunctionName()
+    this.state = 2081
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2080
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2083
+    this.match(CypherParser.T__18)
+    this.state = 2085
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2084
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2087
+    this.filterExpression()
+    this.state = 2089
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2088
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2091
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NoneFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_noneFunctionName
+  return this
+}
+
+NoneFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+NoneFunctionNameContext.prototype.constructor = NoneFunctionNameContext
+
+NoneFunctionNameContext.prototype.NONE = function() {
+  return this.getToken(CypherParser.NONE, 0)
+}
+
+NoneFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNoneFunctionName(this)
+  }
+}
+
+NoneFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNoneFunctionName(this)
+  }
+}
+
+CypherParser.NoneFunctionNameContext = NoneFunctionNameContext
+
+CypherParser.prototype.noneFunctionName = function() {
+  var localctx = new NoneFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 298, CypherParser.RULE_noneFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2093
+    this.match(CypherParser.NONE)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SingleFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_singleFunction
+  return this
+}
+
+SingleFunctionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+SingleFunctionContext.prototype.constructor = SingleFunctionContext
+
+SingleFunctionContext.prototype.singleFunctionName = function() {
+  return this.getTypedRuleContext(SingleFunctionNameContext, 0)
+}
+
+SingleFunctionContext.prototype.filterExpression = function() {
+  return this.getTypedRuleContext(FilterExpressionContext, 0)
+}
+
+SingleFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+SingleFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSingleFunction(this)
+  }
+}
+
+SingleFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSingleFunction(this)
+  }
+}
+
+CypherParser.SingleFunctionContext = SingleFunctionContext
+
+CypherParser.prototype.singleFunction = function() {
+  var localctx = new SingleFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 300, CypherParser.RULE_singleFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2095
+    this.singleFunctionName()
+    this.state = 2097
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2096
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2099
+    this.match(CypherParser.T__18)
+    this.state = 2101
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2100
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2103
+    this.filterExpression()
+    this.state = 2105
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2104
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2107
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SingleFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_singleFunctionName
+  return this
+}
+
+SingleFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+SingleFunctionNameContext.prototype.constructor = SingleFunctionNameContext
+
+SingleFunctionNameContext.prototype.SINGLE = function() {
+  return this.getToken(CypherParser.SINGLE, 0)
+}
+
+SingleFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSingleFunctionName(this)
+  }
+}
+
+SingleFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSingleFunctionName(this)
+  }
+}
+
+CypherParser.SingleFunctionNameContext = SingleFunctionNameContext
+
+CypherParser.prototype.singleFunctionName = function() {
+  var localctx = new SingleFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 302, CypherParser.RULE_singleFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2109
+    this.match(CypherParser.SINGLE)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ExtractFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_extractFunction
+  return this
+}
+
+ExtractFunctionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ExtractFunctionContext.prototype.constructor = ExtractFunctionContext
+
+ExtractFunctionContext.prototype.extractFunctionName = function() {
+  return this.getTypedRuleContext(ExtractFunctionNameContext, 0)
+}
+
+ExtractFunctionContext.prototype.filterExpression = function() {
+  return this.getTypedRuleContext(FilterExpressionContext, 0)
+}
+
+ExtractFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ExtractFunctionContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+ExtractFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterExtractFunction(this)
+  }
+}
+
+ExtractFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitExtractFunction(this)
+  }
+}
+
+CypherParser.ExtractFunctionContext = ExtractFunctionContext
+
+CypherParser.prototype.extractFunction = function() {
+  var localctx = new ExtractFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 304, CypherParser.RULE_extractFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2111
+    this.extractFunctionName()
+    this.state = 2113
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2112
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2115
+    this.match(CypherParser.T__18)
+    this.state = 2117
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2116
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2119
+    this.filterExpression()
+    this.state = 2128
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 308, this._ctx)
+    if (la_ === 1) {
+      this.state = 2121
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2120
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2123
+      this.match(CypherParser.T__21)
+      this.state = 2125
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2124
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2127
+      this.expression()
+    }
+    this.state = 2131
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2130
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2133
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ExtractFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_extractFunctionName
+  return this
+}
+
+ExtractFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ExtractFunctionNameContext.prototype.constructor = ExtractFunctionNameContext
+
+ExtractFunctionNameContext.prototype.EXTRACT = function() {
+  return this.getToken(CypherParser.EXTRACT, 0)
+}
+
+ExtractFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterExtractFunctionName(this)
+  }
+}
+
+ExtractFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitExtractFunctionName(this)
+  }
+}
+
+CypherParser.ExtractFunctionNameContext = ExtractFunctionNameContext
+
+CypherParser.prototype.extractFunctionName = function() {
+  var localctx = new ExtractFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 306, CypherParser.RULE_extractFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2135
+    this.match(CypherParser.EXTRACT)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ReduceFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_reduceFunction
+  return this
+}
+
+ReduceFunctionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ReduceFunctionContext.prototype.constructor = ReduceFunctionContext
+
+ReduceFunctionContext.prototype.reduceFunctionName = function() {
+  return this.getTypedRuleContext(ReduceFunctionNameContext, 0)
+}
+
+ReduceFunctionContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+ReduceFunctionContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+ReduceFunctionContext.prototype.idInColl = function() {
+  return this.getTypedRuleContext(IdInCollContext, 0)
+}
+
+ReduceFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ReduceFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterReduceFunction(this)
+  }
+}
+
+ReduceFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitReduceFunction(this)
+  }
+}
+
+CypherParser.ReduceFunctionContext = ReduceFunctionContext
+
+CypherParser.prototype.reduceFunction = function() {
+  var localctx = new ReduceFunctionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 308, CypherParser.RULE_reduceFunction)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2137
+    this.reduceFunctionName()
+    this.state = 2139
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2138
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2141
+    this.match(CypherParser.T__18)
+    this.state = 2143
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2142
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2145
+    this.variable()
+    this.state = 2147
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2146
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2149
+    this.match(CypherParser.T__11)
+    this.state = 2151
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2150
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2153
+    this.expression()
+    this.state = 2155
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2154
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2157
+    this.match(CypherParser.T__14)
+    this.state = 2159
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2158
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2161
+    this.idInColl()
+    this.state = 2163
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2162
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2165
+    this.match(CypherParser.T__21)
+    this.state = 2167
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2166
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2169
+    this.expression()
+    this.state = 2171
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2170
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2173
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ReduceFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_reduceFunctionName
+  return this
+}
+
+ReduceFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ReduceFunctionNameContext.prototype.constructor = ReduceFunctionNameContext
+
+ReduceFunctionNameContext.prototype.REDUCE = function() {
+  return this.getToken(CypherParser.REDUCE, 0)
+}
+
+ReduceFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterReduceFunctionName(this)
+  }
+}
+
+ReduceFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitReduceFunctionName(this)
+  }
+}
+
+CypherParser.ReduceFunctionNameContext = ReduceFunctionNameContext
+
+CypherParser.prototype.reduceFunctionName = function() {
+  var localctx = new ReduceFunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 310, CypherParser.RULE_reduceFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2175
+    this.match(CypherParser.REDUCE)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ShortestPathPatternFunctionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_shortestPathPatternFunction
+  return this
+}
+
+ShortestPathPatternFunctionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ShortestPathPatternFunctionContext.prototype.constructor = ShortestPathPatternFunctionContext
+
+ShortestPathPatternFunctionContext.prototype.shortestPathFunctionName = function() {
+  return this.getTypedRuleContext(ShortestPathFunctionNameContext, 0)
+}
+
+ShortestPathPatternFunctionContext.prototype.patternElement = function() {
+  return this.getTypedRuleContext(PatternElementContext, 0)
+}
+
+ShortestPathPatternFunctionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ShortestPathPatternFunctionContext.prototype.allShortestPathFunctionName = function() {
+  return this.getTypedRuleContext(AllShortestPathFunctionNameContext, 0)
+}
+
+ShortestPathPatternFunctionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterShortestPathPatternFunction(this)
+  }
+}
+
+ShortestPathPatternFunctionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitShortestPathPatternFunction(this)
+  }
+}
+
+CypherParser.ShortestPathPatternFunctionContext = ShortestPathPatternFunctionContext
+
+CypherParser.prototype.shortestPathPatternFunction = function() {
+  var localctx = new ShortestPathPatternFunctionContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 312, CypherParser.RULE_shortestPathPatternFunction)
+  var _la = 0 // Token type
+  try {
+    this.state = 2205
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.SHORTESTPATH:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2177
+        this.shortestPathFunctionName()
+        this.state = 2179
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2178
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2181
+        this.match(CypherParser.T__18)
+        this.state = 2183
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2182
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2185
+        this.patternElement()
+        this.state = 2187
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2186
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2189
+        this.match(CypherParser.T__19)
+        break
+      case CypherParser.ALLSHORTESTPATHS:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2191
+        this.allShortestPathFunctionName()
+        this.state = 2193
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2192
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2195
+        this.match(CypherParser.T__18)
+        this.state = 2197
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2196
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2199
+        this.patternElement()
+        this.state = 2201
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2200
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2203
+        this.match(CypherParser.T__19)
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ShortestPathFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_shortestPathFunctionName
+  return this
+}
+
+ShortestPathFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ShortestPathFunctionNameContext.prototype.constructor = ShortestPathFunctionNameContext
+
+ShortestPathFunctionNameContext.prototype.SHORTESTPATH = function() {
+  return this.getToken(CypherParser.SHORTESTPATH, 0)
+}
+
+ShortestPathFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterShortestPathFunctionName(this)
+  }
+}
+
+ShortestPathFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitShortestPathFunctionName(this)
+  }
+}
+
+CypherParser.ShortestPathFunctionNameContext = ShortestPathFunctionNameContext
+
+CypherParser.prototype.shortestPathFunctionName = function() {
+  var localctx = new ShortestPathFunctionNameContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 314, CypherParser.RULE_shortestPathFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2207
+    this.match(CypherParser.SHORTESTPATH)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AllShortestPathFunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_allShortestPathFunctionName
+  return this
+}
+
+AllShortestPathFunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AllShortestPathFunctionNameContext.prototype.constructor = AllShortestPathFunctionNameContext
+
+AllShortestPathFunctionNameContext.prototype.ALLSHORTESTPATHS = function() {
+  return this.getToken(CypherParser.ALLSHORTESTPATHS, 0)
+}
+
+AllShortestPathFunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAllShortestPathFunctionName(this)
+  }
+}
+
+AllShortestPathFunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAllShortestPathFunctionName(this)
+  }
+}
+
+CypherParser.AllShortestPathFunctionNameContext = AllShortestPathFunctionNameContext
+
+CypherParser.prototype.allShortestPathFunctionName = function() {
+  var localctx = new AllShortestPathFunctionNameContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 316, CypherParser.RULE_allShortestPathFunctionName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2209
+    this.match(CypherParser.ALLSHORTESTPATHS)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AtomContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_atom
+  return this
+}
+
+AtomContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+AtomContext.prototype.constructor = AtomContext
+
+AtomContext.prototype.literal = function() {
+  return this.getTypedRuleContext(LiteralContext, 0)
+}
+
+AtomContext.prototype.parameter = function() {
+  return this.getTypedRuleContext(ParameterContext, 0)
+}
+
+AtomContext.prototype.caseExpression = function() {
+  return this.getTypedRuleContext(CaseExpressionContext, 0)
+}
+
+AtomContext.prototype.COUNT = function() {
+  return this.getToken(CypherParser.COUNT, 0)
+}
+
+AtomContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+AtomContext.prototype.listComprehension = function() {
+  return this.getTypedRuleContext(ListComprehensionContext, 0)
+}
+
+AtomContext.prototype.patternComprehension = function() {
+  return this.getTypedRuleContext(PatternComprehensionContext, 0)
+}
+
+AtomContext.prototype.filterFunction = function() {
+  return this.getTypedRuleContext(FilterFunctionContext, 0)
+}
+
+AtomContext.prototype.extractFunction = function() {
+  return this.getTypedRuleContext(ExtractFunctionContext, 0)
+}
+
+AtomContext.prototype.reduceFunction = function() {
+  return this.getTypedRuleContext(ReduceFunctionContext, 0)
+}
+
+AtomContext.prototype.allFunction = function() {
+  return this.getTypedRuleContext(AllFunctionContext, 0)
+}
+
+AtomContext.prototype.anyFunction = function() {
+  return this.getTypedRuleContext(AnyFunctionContext, 0)
+}
+
+AtomContext.prototype.noneFunction = function() {
+  return this.getTypedRuleContext(NoneFunctionContext, 0)
+}
+
+AtomContext.prototype.singleFunction = function() {
+  return this.getTypedRuleContext(SingleFunctionContext, 0)
+}
+
+AtomContext.prototype.existsFunction = function() {
+  return this.getTypedRuleContext(ExistsFunctionContext, 0)
+}
+
+AtomContext.prototype.shortestPathPatternFunction = function() {
+  return this.getTypedRuleContext(ShortestPathPatternFunctionContext, 0)
+}
+
+AtomContext.prototype.relationshipsPattern = function() {
+  return this.getTypedRuleContext(RelationshipsPatternContext, 0)
+}
+
+AtomContext.prototype.parenthesizedExpression = function() {
+  return this.getTypedRuleContext(ParenthesizedExpressionContext, 0)
+}
+
+AtomContext.prototype.functionInvocation = function() {
+  return this.getTypedRuleContext(FunctionInvocationContext, 0)
+}
+
+AtomContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+AtomContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAtom(this)
+  }
+}
+
+AtomContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAtom(this)
+  }
+}
+
+CypherParser.AtomContext = AtomContext
+
+CypherParser.prototype.atom = function() {
+  var localctx = new AtomContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 318, CypherParser.RULE_atom)
+  var _la = 0 // Token type
+  try {
+    this.state = 2242
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 329, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2211
+        this.literal()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2212
+        this.parameter()
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 2213
+        this.caseExpression()
+        break
+
+      case 4:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 2214
+        this.match(CypherParser.COUNT)
+        this.state = 2216
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2215
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2218
+        this.match(CypherParser.T__18)
+        this.state = 2220
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2219
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2222
+        this.match(CypherParser.T__22)
+        this.state = 2224
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2223
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2226
+        this.match(CypherParser.T__19)
+        break
+
+      case 5:
+        this.enterOuterAlt(localctx, 5)
+        this.state = 2227
+        this.listComprehension()
+        break
+
+      case 6:
+        this.enterOuterAlt(localctx, 6)
+        this.state = 2228
+        this.patternComprehension()
+        break
+
+      case 7:
+        this.enterOuterAlt(localctx, 7)
+        this.state = 2229
+        this.filterFunction()
+        break
+
+      case 8:
+        this.enterOuterAlt(localctx, 8)
+        this.state = 2230
+        this.extractFunction()
+        break
+
+      case 9:
+        this.enterOuterAlt(localctx, 9)
+        this.state = 2231
+        this.reduceFunction()
+        break
+
+      case 10:
+        this.enterOuterAlt(localctx, 10)
+        this.state = 2232
+        this.allFunction()
+        break
+
+      case 11:
+        this.enterOuterAlt(localctx, 11)
+        this.state = 2233
+        this.anyFunction()
+        break
+
+      case 12:
+        this.enterOuterAlt(localctx, 12)
+        this.state = 2234
+        this.noneFunction()
+        break
+
+      case 13:
+        this.enterOuterAlt(localctx, 13)
+        this.state = 2235
+        this.singleFunction()
+        break
+
+      case 14:
+        this.enterOuterAlt(localctx, 14)
+        this.state = 2236
+        this.existsFunction()
+        break
+
+      case 15:
+        this.enterOuterAlt(localctx, 15)
+        this.state = 2237
+        this.shortestPathPatternFunction()
+        break
+
+      case 16:
+        this.enterOuterAlt(localctx, 16)
+        this.state = 2238
+        this.relationshipsPattern()
+        break
+
+      case 17:
+        this.enterOuterAlt(localctx, 17)
+        this.state = 2239
+        this.parenthesizedExpression()
+        break
+
+      case 18:
+        this.enterOuterAlt(localctx, 18)
+        this.state = 2240
+        this.functionInvocation()
+        break
+
+      case 19:
+        this.enterOuterAlt(localctx, 19)
+        this.state = 2241
+        this.variable()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_literal
+  return this
+}
+
+LiteralContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+LiteralContext.prototype.constructor = LiteralContext
+
+LiteralContext.prototype.numberLiteral = function() {
+  return this.getTypedRuleContext(NumberLiteralContext, 0)
+}
+
+LiteralContext.prototype.stringLiteral = function() {
+  return this.getTypedRuleContext(StringLiteralContext, 0)
+}
+
+LiteralContext.prototype.booleanLiteral = function() {
+  return this.getTypedRuleContext(BooleanLiteralContext, 0)
+}
+
+LiteralContext.prototype.NULL = function() {
+  return this.getToken(CypherParser.NULL, 0)
+}
+
+LiteralContext.prototype.mapLiteral = function() {
+  return this.getTypedRuleContext(MapLiteralContext, 0)
+}
+
+LiteralContext.prototype.listLiteral = function() {
+  return this.getTypedRuleContext(ListLiteralContext, 0)
+}
+
+LiteralContext.prototype.mapProjection = function() {
+  return this.getTypedRuleContext(MapProjectionContext, 0)
+}
+
+LiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLiteral(this)
+  }
+}
+
+LiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLiteral(this)
+  }
+}
+
+CypherParser.LiteralContext = LiteralContext
+
+CypherParser.prototype.literal = function() {
+  var localctx = new LiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 320, CypherParser.RULE_literal)
+  try {
+    this.state = 2251
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 330, this._ctx)
+    switch (la_) {
+      case 1:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2244
+        this.numberLiteral()
+        break
+
+      case 2:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2245
+        this.stringLiteral()
+        break
+
+      case 3:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 2246
+        this.booleanLiteral()
+        break
+
+      case 4:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 2247
+        this.match(CypherParser.NULL)
+        break
+
+      case 5:
+        this.enterOuterAlt(localctx, 5)
+        this.state = 2248
+        this.mapLiteral()
+        break
+
+      case 6:
+        this.enterOuterAlt(localctx, 6)
+        this.state = 2249
+        this.listLiteral()
+        break
+
+      case 7:
+        this.enterOuterAlt(localctx, 7)
+        this.state = 2250
+        this.mapProjection()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function StringLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_stringLiteral
+  return this
+}
+
+StringLiteralContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+StringLiteralContext.prototype.constructor = StringLiteralContext
+
+StringLiteralContext.prototype.StringLiteral = function() {
+  return this.getToken(CypherParser.StringLiteral, 0)
+}
+
+StringLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterStringLiteral(this)
+  }
+}
+
+StringLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitStringLiteral(this)
+  }
+}
+
+CypherParser.StringLiteralContext = StringLiteralContext
+
+CypherParser.prototype.stringLiteral = function() {
+  var localctx = new StringLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 322, CypherParser.RULE_stringLiteral)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2253
+    this.match(CypherParser.StringLiteral)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function BooleanLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_booleanLiteral
+  return this
+}
+
+BooleanLiteralContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+BooleanLiteralContext.prototype.constructor = BooleanLiteralContext
+
+BooleanLiteralContext.prototype.TRUE = function() {
+  return this.getToken(CypherParser.TRUE, 0)
+}
+
+BooleanLiteralContext.prototype.FALSE = function() {
+  return this.getToken(CypherParser.FALSE, 0)
+}
+
+BooleanLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterBooleanLiteral(this)
+  }
+}
+
+BooleanLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitBooleanLiteral(this)
+  }
+}
+
+CypherParser.BooleanLiteralContext = BooleanLiteralContext
+
+CypherParser.prototype.booleanLiteral = function() {
+  var localctx = new BooleanLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 324, CypherParser.RULE_booleanLiteral)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2255
+    _la = this._input.LA(1)
+    if (!(_la === CypherParser.TRUE || _la === CypherParser.FALSE)) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ListLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_listLiteral
+  return this
+}
+
+ListLiteralContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ListLiteralContext.prototype.constructor = ListLiteralContext
+
+ListLiteralContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ListLiteralContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+ListLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterListLiteral(this)
+  }
+}
+
+ListLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitListLiteral(this)
+  }
+}
+
+CypherParser.ListLiteralContext = ListLiteralContext
+
+CypherParser.prototype.listLiteral = function() {
+  var localctx = new ListLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 326, CypherParser.RULE_listLiteral)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2257
+    this.match(CypherParser.T__16)
+    this.state = 2259
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2258
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2278
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      ((_la & ~0x1f) == 0 &&
+        ((1 << _la) &
+          ((1 << CypherParser.T__2) |
+            (1 << CypherParser.T__12) |
+            (1 << CypherParser.T__13) |
+            (1 << CypherParser.T__16) |
+            (1 << CypherParser.T__18))) !==
+          0) ||
+      (((_la - 34) & ~0x1f) == 0 &&
+        ((1 << (_la - 34)) &
+          ((1 << (CypherParser.T__33 - 34)) |
+            (1 << (CypherParser.CYPHER - 34)) |
+            (1 << (CypherParser.EXPLAIN - 34)) |
+            (1 << (CypherParser.PROFILE - 34)) |
+            (1 << (CypherParser.USING - 34)) |
+            (1 << (CypherParser.PERIODIC - 34)) |
+            (1 << (CypherParser.COMMIT - 34)) |
+            (1 << (CypherParser.UNION - 34)) |
+            (1 << (CypherParser.ALL - 34)) |
+            (1 << (CypherParser.CREATE - 34)) |
+            (1 << (CypherParser.DROP - 34)) |
+            (1 << (CypherParser.INDEX - 34)) |
+            (1 << (CypherParser.ON - 34)))) !==
+          0) ||
+      (((_la - 66) & ~0x1f) == 0 &&
+        ((1 << (_la - 66)) &
+          ((1 << (CypherParser.CONSTRAINT - 66)) |
+            (1 << (CypherParser.ASSERT - 66)) |
+            (1 << (CypherParser.IS - 66)) |
+            (1 << (CypherParser.UNIQUE - 66)) |
+            (1 << (CypherParser.EXISTS - 66)) |
+            (1 << (CypherParser.LOAD - 66)) |
+            (1 << (CypherParser.CSV - 66)) |
+            (1 << (CypherParser.WITH - 66)) |
+            (1 << (CypherParser.HEADERS - 66)) |
+            (1 << (CypherParser.FROM - 66)) |
+            (1 << (CypherParser.AS - 66)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 66)) |
+            (1 << (CypherParser.OPTIONAL - 66)) |
+            (1 << (CypherParser.MATCH - 66)) |
+            (1 << (CypherParser.UNWIND - 66)) |
+            (1 << (CypherParser.MERGE - 66)) |
+            (1 << (CypherParser.SET - 66)) |
+            (1 << (CypherParser.DETACH - 66)) |
+            (1 << (CypherParser.DELETE - 66)) |
+            (1 << (CypherParser.REMOVE - 66)) |
+            (1 << (CypherParser.FOREACH - 66)) |
+            (1 << (CypherParser.IN - 66)) |
+            (1 << (CypherParser.DISTINCT - 66)) |
+            (1 << (CypherParser.RETURN - 66)) |
+            (1 << (CypherParser.ORDER - 66)) |
+            (1 << (CypherParser.BY - 66)) |
+            (1 << (CypherParser.L_SKIP - 66)) |
+            (1 << (CypherParser.LIMIT - 66)) |
+            (1 << (CypherParser.ASCENDING - 66)) |
+            (1 << (CypherParser.ASC - 66)) |
+            (1 << (CypherParser.DESCENDING - 66)) |
+            (1 << (CypherParser.DESC - 66)))) !==
+          0) ||
+      (((_la - 98) & ~0x1f) == 0 &&
+        ((1 << (_la - 98)) &
+          ((1 << (CypherParser.JOIN - 98)) |
+            (1 << (CypherParser.SCAN - 98)) |
+            (1 << (CypherParser.START - 98)) |
+            (1 << (CypherParser.NODE - 98)) |
+            (1 << (CypherParser.RELATIONSHIP - 98)) |
+            (1 << (CypherParser.REL - 98)) |
+            (1 << (CypherParser.WHERE - 98)) |
+            (1 << (CypherParser.SHORTESTPATH - 98)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
+            (1 << (CypherParser.OR - 98)) |
+            (1 << (CypherParser.XOR - 98)) |
+            (1 << (CypherParser.AND - 98)) |
+            (1 << (CypherParser.NOT - 98)) |
+            (1 << (CypherParser.STARTS - 98)) |
+            (1 << (CypherParser.ENDS - 98)) |
+            (1 << (CypherParser.CONTAINS - 98)) |
+            (1 << (CypherParser.NULL - 98)) |
+            (1 << (CypherParser.COUNT - 98)) |
+            (1 << (CypherParser.FILTER - 98)) |
+            (1 << (CypherParser.EXTRACT - 98)) |
+            (1 << (CypherParser.ANY - 98)) |
+            (1 << (CypherParser.NONE - 98)) |
+            (1 << (CypherParser.SINGLE - 98)) |
+            (1 << (CypherParser.TRUE - 98)) |
+            (1 << (CypherParser.FALSE - 98)) |
+            (1 << (CypherParser.REDUCE - 98)) |
+            (1 << (CypherParser.CASE - 98)) |
+            (1 << (CypherParser.ELSE - 98)) |
+            (1 << (CypherParser.END - 98)) |
+            (1 << (CypherParser.WHEN - 98)) |
+            (1 << (CypherParser.THEN - 98)) |
+            (1 << (CypherParser.CALL - 98)))) !==
+          0) ||
+      (((_la - 130) & ~0x1f) == 0 &&
+        ((1 << (_la - 130)) &
+          ((1 << (CypherParser.YIELD - 130)) |
+            (1 << (CypherParser.KEY - 130)) |
+            (1 << (CypherParser.StringLiteral - 130)) |
+            (1 << (CypherParser.HexInteger - 130)) |
+            (1 << (CypherParser.DecimalInteger - 130)) |
+            (1 << (CypherParser.OctalInteger - 130)) |
+            (1 << (CypherParser.HexLetter - 130)) |
+            (1 << (CypherParser.ExponentDecimalReal - 130)) |
+            (1 << (CypherParser.RegularDecimalReal - 130)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 130)) |
+            (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
+          0)
+    ) {
+      this.state = 2261
+      this.expression()
+      this.state = 2263
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2262
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2275
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      while (_la === CypherParser.T__14) {
+        this.state = 2265
+        this.match(CypherParser.T__14)
+        this.state = 2267
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2266
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2269
+        this.expression()
+        this.state = 2271
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2270
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2277
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+      }
+    }
+
+    this.state = 2280
+    this.match(CypherParser.T__17)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PartialComparisonExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_partialComparisonExpression
+  return this
+}
+
+PartialComparisonExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PartialComparisonExpressionContext.prototype.constructor = PartialComparisonExpressionContext
+
+PartialComparisonExpressionContext.prototype.addOrSubtractExpression = function() {
+  return this.getTypedRuleContext(AddOrSubtractExpressionContext, 0)
+}
+
+PartialComparisonExpressionContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+PartialComparisonExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPartialComparisonExpression(this)
+  }
+}
+
+PartialComparisonExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPartialComparisonExpression(this)
+  }
+}
+
+CypherParser.PartialComparisonExpressionContext = PartialComparisonExpressionContext
+
+CypherParser.prototype.partialComparisonExpression = function() {
+  var localctx = new PartialComparisonExpressionContext(
+    this,
+    this._ctx,
+    this.state
+  )
+  this.enterRule(localctx, 328, CypherParser.RULE_partialComparisonExpression)
+  var _la = 0 // Token type
+  try {
+    this.state = 2317
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.T__11:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2282
+        this.match(CypherParser.T__11)
+        this.state = 2284
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2283
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2286
+        this.addOrSubtractExpression()
+        break
+      case CypherParser.T__27:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2287
+        this.match(CypherParser.T__27)
+        this.state = 2289
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2288
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2291
+        this.addOrSubtractExpression()
+        break
+      case CypherParser.T__28:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 2292
+        this.match(CypherParser.T__28)
+        this.state = 2294
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2293
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2296
+        this.addOrSubtractExpression()
+        break
+      case CypherParser.T__29:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 2297
+        this.match(CypherParser.T__29)
+        this.state = 2299
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2298
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2301
+        this.addOrSubtractExpression()
+        break
+      case CypherParser.T__30:
+        this.enterOuterAlt(localctx, 5)
+        this.state = 2302
+        this.match(CypherParser.T__30)
+        this.state = 2304
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2303
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2306
+        this.addOrSubtractExpression()
+        break
+      case CypherParser.T__31:
+        this.enterOuterAlt(localctx, 6)
+        this.state = 2307
+        this.match(CypherParser.T__31)
+        this.state = 2309
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2308
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2311
+        this.addOrSubtractExpression()
+        break
+      case CypherParser.T__32:
+        this.enterOuterAlt(localctx, 7)
+        this.state = 2312
+        this.match(CypherParser.T__32)
+        this.state = 2314
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2313
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2316
+        this.addOrSubtractExpression()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ParenthesizedExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_parenthesizedExpression
+  return this
+}
+
+ParenthesizedExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ParenthesizedExpressionContext.prototype.constructor = ParenthesizedExpressionContext
+
+ParenthesizedExpressionContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+ParenthesizedExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ParenthesizedExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterParenthesizedExpression(this)
+  }
+}
+
+ParenthesizedExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitParenthesizedExpression(this)
+  }
+}
+
+CypherParser.ParenthesizedExpressionContext = ParenthesizedExpressionContext
+
+CypherParser.prototype.parenthesizedExpression = function() {
+  var localctx = new ParenthesizedExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 330, CypherParser.RULE_parenthesizedExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2319
+    this.match(CypherParser.T__18)
+    this.state = 2321
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2320
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2323
+    this.expression()
+    this.state = 2325
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2324
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2327
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RelationshipsPatternContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_relationshipsPattern
+  return this
+}
+
+RelationshipsPatternContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RelationshipsPatternContext.prototype.constructor = RelationshipsPatternContext
+
+RelationshipsPatternContext.prototype.nodePattern = function() {
+  return this.getTypedRuleContext(NodePatternContext, 0)
+}
+
+RelationshipsPatternContext.prototype.patternElementChain = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PatternElementChainContext)
+  } else {
+    return this.getTypedRuleContext(PatternElementChainContext, i)
+  }
+}
+
+RelationshipsPatternContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+RelationshipsPatternContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRelationshipsPattern(this)
+  }
+}
+
+RelationshipsPatternContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRelationshipsPattern(this)
+  }
+}
+
+CypherParser.RelationshipsPatternContext = RelationshipsPatternContext
+
+CypherParser.prototype.relationshipsPattern = function() {
+  var localctx = new RelationshipsPatternContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 332, CypherParser.RULE_relationshipsPattern)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2329
+    this.nodePattern()
+    this.state = 2334
+    this._errHandler.sync(this)
+    var _alt = 1
+    do {
+      switch (_alt) {
+        case 1:
+          this.state = 2331
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+          if (_la === CypherParser.SP) {
+            this.state = 2330
+            this.match(CypherParser.SP)
+          }
+
+          this.state = 2333
+          this.patternElementChain()
+          break
+        default:
+          throw new antlr4.error.NoViableAltException(this)
+      }
+      this.state = 2336
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 348, this._ctx)
+    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function FilterExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_filterExpression
+  return this
+}
+
+FilterExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+FilterExpressionContext.prototype.constructor = FilterExpressionContext
+
+FilterExpressionContext.prototype.idInColl = function() {
+  return this.getTypedRuleContext(IdInCollContext, 0)
+}
+
+FilterExpressionContext.prototype.where = function() {
+  return this.getTypedRuleContext(WhereContext, 0)
+}
+
+FilterExpressionContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+FilterExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterFilterExpression(this)
+  }
+}
+
+FilterExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitFilterExpression(this)
+  }
+}
+
+CypherParser.FilterExpressionContext = FilterExpressionContext
+
+CypherParser.prototype.filterExpression = function() {
+  var localctx = new FilterExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 334, CypherParser.RULE_filterExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2338
+    this.idInColl()
+    this.state = 2343
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 350, this._ctx)
+    if (la_ === 1) {
+      this.state = 2340
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2339
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2342
+      this.where()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function IdInCollContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_idInColl
+  return this
+}
+
+IdInCollContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+IdInCollContext.prototype.constructor = IdInCollContext
+
+IdInCollContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+IdInCollContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+IdInCollContext.prototype.IN = function() {
+  return this.getToken(CypherParser.IN, 0)
+}
+
+IdInCollContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+IdInCollContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterIdInColl(this)
+  }
+}
+
+IdInCollContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitIdInColl(this)
+  }
+}
+
+CypherParser.IdInCollContext = IdInCollContext
+
+CypherParser.prototype.idInColl = function() {
+  var localctx = new IdInCollContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 336, CypherParser.RULE_idInColl)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2345
+    this.variable()
+    this.state = 2346
+    this.match(CypherParser.SP)
+    this.state = 2347
+    this.match(CypherParser.IN)
+    this.state = 2348
+    this.match(CypherParser.SP)
+    this.state = 2349
+    this.expression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function FunctionInvocationContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_functionInvocation
+  return this
+}
+
+FunctionInvocationContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+FunctionInvocationContext.prototype.constructor = FunctionInvocationContext
+
+FunctionInvocationContext.prototype.functionInvocationBody = function() {
+  return this.getTypedRuleContext(FunctionInvocationBodyContext, 0)
+}
+
+FunctionInvocationContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+FunctionInvocationContext.prototype.DISTINCT = function() {
+  return this.getToken(CypherParser.DISTINCT, 0)
+}
+
+FunctionInvocationContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+FunctionInvocationContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterFunctionInvocation(this)
+  }
+}
+
+FunctionInvocationContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitFunctionInvocation(this)
+  }
+}
+
+CypherParser.FunctionInvocationContext = FunctionInvocationContext
+
+CypherParser.prototype.functionInvocation = function() {
+  var localctx = new FunctionInvocationContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 338, CypherParser.RULE_functionInvocation)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2351
+    this.functionInvocationBody()
+    this.state = 2353
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2352
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2355
+    this.match(CypherParser.T__18)
+    this.state = 2357
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2356
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2363
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 354, this._ctx)
+    if (la_ === 1) {
+      this.state = 2359
+      this.match(CypherParser.DISTINCT)
+      this.state = 2361
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2360
+        this.match(CypherParser.SP)
+      }
+    }
+    this.state = 2382
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      ((_la & ~0x1f) == 0 &&
+        ((1 << _la) &
+          ((1 << CypherParser.T__2) |
+            (1 << CypherParser.T__12) |
+            (1 << CypherParser.T__13) |
+            (1 << CypherParser.T__16) |
+            (1 << CypherParser.T__18))) !==
+          0) ||
+      (((_la - 34) & ~0x1f) == 0 &&
+        ((1 << (_la - 34)) &
+          ((1 << (CypherParser.T__33 - 34)) |
+            (1 << (CypherParser.CYPHER - 34)) |
+            (1 << (CypherParser.EXPLAIN - 34)) |
+            (1 << (CypherParser.PROFILE - 34)) |
+            (1 << (CypherParser.USING - 34)) |
+            (1 << (CypherParser.PERIODIC - 34)) |
+            (1 << (CypherParser.COMMIT - 34)) |
+            (1 << (CypherParser.UNION - 34)) |
+            (1 << (CypherParser.ALL - 34)) |
+            (1 << (CypherParser.CREATE - 34)) |
+            (1 << (CypherParser.DROP - 34)) |
+            (1 << (CypherParser.INDEX - 34)) |
+            (1 << (CypherParser.ON - 34)))) !==
+          0) ||
+      (((_la - 66) & ~0x1f) == 0 &&
+        ((1 << (_la - 66)) &
+          ((1 << (CypherParser.CONSTRAINT - 66)) |
+            (1 << (CypherParser.ASSERT - 66)) |
+            (1 << (CypherParser.IS - 66)) |
+            (1 << (CypherParser.UNIQUE - 66)) |
+            (1 << (CypherParser.EXISTS - 66)) |
+            (1 << (CypherParser.LOAD - 66)) |
+            (1 << (CypherParser.CSV - 66)) |
+            (1 << (CypherParser.WITH - 66)) |
+            (1 << (CypherParser.HEADERS - 66)) |
+            (1 << (CypherParser.FROM - 66)) |
+            (1 << (CypherParser.AS - 66)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 66)) |
+            (1 << (CypherParser.OPTIONAL - 66)) |
+            (1 << (CypherParser.MATCH - 66)) |
+            (1 << (CypherParser.UNWIND - 66)) |
+            (1 << (CypherParser.MERGE - 66)) |
+            (1 << (CypherParser.SET - 66)) |
+            (1 << (CypherParser.DETACH - 66)) |
+            (1 << (CypherParser.DELETE - 66)) |
+            (1 << (CypherParser.REMOVE - 66)) |
+            (1 << (CypherParser.FOREACH - 66)) |
+            (1 << (CypherParser.IN - 66)) |
+            (1 << (CypherParser.DISTINCT - 66)) |
+            (1 << (CypherParser.RETURN - 66)) |
+            (1 << (CypherParser.ORDER - 66)) |
+            (1 << (CypherParser.BY - 66)) |
+            (1 << (CypherParser.L_SKIP - 66)) |
+            (1 << (CypherParser.LIMIT - 66)) |
+            (1 << (CypherParser.ASCENDING - 66)) |
+            (1 << (CypherParser.ASC - 66)) |
+            (1 << (CypherParser.DESCENDING - 66)) |
+            (1 << (CypherParser.DESC - 66)))) !==
+          0) ||
+      (((_la - 98) & ~0x1f) == 0 &&
+        ((1 << (_la - 98)) &
+          ((1 << (CypherParser.JOIN - 98)) |
+            (1 << (CypherParser.SCAN - 98)) |
+            (1 << (CypherParser.START - 98)) |
+            (1 << (CypherParser.NODE - 98)) |
+            (1 << (CypherParser.RELATIONSHIP - 98)) |
+            (1 << (CypherParser.REL - 98)) |
+            (1 << (CypherParser.WHERE - 98)) |
+            (1 << (CypherParser.SHORTESTPATH - 98)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
+            (1 << (CypherParser.OR - 98)) |
+            (1 << (CypherParser.XOR - 98)) |
+            (1 << (CypherParser.AND - 98)) |
+            (1 << (CypherParser.NOT - 98)) |
+            (1 << (CypherParser.STARTS - 98)) |
+            (1 << (CypherParser.ENDS - 98)) |
+            (1 << (CypherParser.CONTAINS - 98)) |
+            (1 << (CypherParser.NULL - 98)) |
+            (1 << (CypherParser.COUNT - 98)) |
+            (1 << (CypherParser.FILTER - 98)) |
+            (1 << (CypherParser.EXTRACT - 98)) |
+            (1 << (CypherParser.ANY - 98)) |
+            (1 << (CypherParser.NONE - 98)) |
+            (1 << (CypherParser.SINGLE - 98)) |
+            (1 << (CypherParser.TRUE - 98)) |
+            (1 << (CypherParser.FALSE - 98)) |
+            (1 << (CypherParser.REDUCE - 98)) |
+            (1 << (CypherParser.CASE - 98)) |
+            (1 << (CypherParser.ELSE - 98)) |
+            (1 << (CypherParser.END - 98)) |
+            (1 << (CypherParser.WHEN - 98)) |
+            (1 << (CypherParser.THEN - 98)) |
+            (1 << (CypherParser.CALL - 98)))) !==
+          0) ||
+      (((_la - 130) & ~0x1f) == 0 &&
+        ((1 << (_la - 130)) &
+          ((1 << (CypherParser.YIELD - 130)) |
+            (1 << (CypherParser.KEY - 130)) |
+            (1 << (CypherParser.StringLiteral - 130)) |
+            (1 << (CypherParser.HexInteger - 130)) |
+            (1 << (CypherParser.DecimalInteger - 130)) |
+            (1 << (CypherParser.OctalInteger - 130)) |
+            (1 << (CypherParser.HexLetter - 130)) |
+            (1 << (CypherParser.ExponentDecimalReal - 130)) |
+            (1 << (CypherParser.RegularDecimalReal - 130)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 130)) |
+            (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
+          0)
+    ) {
+      this.state = 2365
+      this.expression()
+      this.state = 2367
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2366
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2379
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      while (_la === CypherParser.T__14) {
+        this.state = 2369
+        this.match(CypherParser.T__14)
+        this.state = 2371
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2370
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2373
+        this.expression()
+        this.state = 2375
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2374
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2381
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+      }
+    }
+
+    this.state = 2384
+    this.match(CypherParser.T__19)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function FunctionInvocationBodyContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_functionInvocationBody
+  return this
+}
+
+FunctionInvocationBodyContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+FunctionInvocationBodyContext.prototype.constructor = FunctionInvocationBodyContext
+
+FunctionInvocationBodyContext.prototype.namespace = function() {
+  return this.getTypedRuleContext(NamespaceContext, 0)
+}
+
+FunctionInvocationBodyContext.prototype.functionName = function() {
+  return this.getTypedRuleContext(FunctionNameContext, 0)
+}
+
+FunctionInvocationBodyContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterFunctionInvocationBody(this)
+  }
+}
+
+FunctionInvocationBodyContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitFunctionInvocationBody(this)
+  }
+}
+
+CypherParser.FunctionInvocationBodyContext = FunctionInvocationBodyContext
+
+CypherParser.prototype.functionInvocationBody = function() {
+  var localctx = new FunctionInvocationBodyContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 340, CypherParser.RULE_functionInvocationBody)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2386
+    this.namespace()
+    this.state = 2387
+    this.functionName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function FunctionNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_functionName
+  return this
+}
+
+FunctionNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+FunctionNameContext.prototype.constructor = FunctionNameContext
+
+FunctionNameContext.prototype.UnescapedSymbolicName = function() {
+  return this.getToken(CypherParser.UnescapedSymbolicName, 0)
+}
+
+FunctionNameContext.prototype.EscapedSymbolicName = function() {
+  return this.getToken(CypherParser.EscapedSymbolicName, 0)
+}
+
+FunctionNameContext.prototype.COUNT = function() {
+  return this.getToken(CypherParser.COUNT, 0)
+}
+
+FunctionNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterFunctionName(this)
+  }
+}
+
+FunctionNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitFunctionName(this)
+  }
+}
+
+CypherParser.FunctionNameContext = FunctionNameContext
+
+CypherParser.prototype.functionName = function() {
+  var localctx = new FunctionNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 342, CypherParser.RULE_functionName)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2389
+    _la = this._input.LA(1)
+    if (
+      !(
+        _la === CypherParser.COUNT ||
+        _la === CypherParser.UnescapedSymbolicName ||
+        _la === CypherParser.EscapedSymbolicName
+      )
+    ) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ProcedureNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_procedureName
+  return this
+}
+
+ProcedureNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ProcedureNameContext.prototype.constructor = ProcedureNameContext
+
+ProcedureNameContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+ProcedureNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterProcedureName(this)
+  }
+}
+
+ProcedureNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitProcedureName(this)
+  }
+}
+
+CypherParser.ProcedureNameContext = ProcedureNameContext
+
+CypherParser.prototype.procedureName = function() {
+  var localctx = new ProcedureNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 344, CypherParser.RULE_procedureName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2391
+    this.symbolicName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ListComprehensionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_listComprehension
+  return this
+}
+
+ListComprehensionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ListComprehensionContext.prototype.constructor = ListComprehensionContext
+
+ListComprehensionContext.prototype.filterExpression = function() {
+  return this.getTypedRuleContext(FilterExpressionContext, 0)
+}
+
+ListComprehensionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+ListComprehensionContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+ListComprehensionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterListComprehension(this)
+  }
+}
+
+ListComprehensionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitListComprehension(this)
+  }
+}
+
+CypherParser.ListComprehensionContext = ListComprehensionContext
+
+CypherParser.prototype.listComprehension = function() {
+  var localctx = new ListComprehensionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 346, CypherParser.RULE_listComprehension)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2393
+    this.match(CypherParser.T__16)
+    this.state = 2395
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2394
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2397
+    this.filterExpression()
+    this.state = 2406
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 363, this._ctx)
+    if (la_ === 1) {
+      this.state = 2399
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2398
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2401
+      this.match(CypherParser.T__21)
+      this.state = 2403
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2402
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2405
+      this.expression()
+    }
+    this.state = 2409
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2408
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2411
+    this.match(CypherParser.T__17)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PatternComprehensionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_patternComprehension
+  return this
+}
+
+PatternComprehensionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PatternComprehensionContext.prototype.constructor = PatternComprehensionContext
+
+PatternComprehensionContext.prototype.relationshipsPattern = function() {
+  return this.getTypedRuleContext(RelationshipsPatternContext, 0)
+}
+
+PatternComprehensionContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+PatternComprehensionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PatternComprehensionContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+PatternComprehensionContext.prototype.WHERE = function() {
+  return this.getToken(CypherParser.WHERE, 0)
+}
+
+PatternComprehensionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPatternComprehension(this)
+  }
+}
+
+PatternComprehensionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPatternComprehension(this)
+  }
+}
+
+CypherParser.PatternComprehensionContext = PatternComprehensionContext
+
+CypherParser.prototype.patternComprehension = function() {
+  var localctx = new PatternComprehensionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 348, CypherParser.RULE_patternComprehension)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2413
+    this.match(CypherParser.T__16)
+    this.state = 2415
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2414
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2425
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      (((_la - 54) & ~0x1f) == 0 &&
+        ((1 << (_la - 54)) &
+          ((1 << (CypherParser.CYPHER - 54)) |
+            (1 << (CypherParser.EXPLAIN - 54)) |
+            (1 << (CypherParser.PROFILE - 54)) |
+            (1 << (CypherParser.USING - 54)) |
+            (1 << (CypherParser.PERIODIC - 54)) |
+            (1 << (CypherParser.COMMIT - 54)) |
+            (1 << (CypherParser.UNION - 54)) |
+            (1 << (CypherParser.ALL - 54)) |
+            (1 << (CypherParser.CREATE - 54)) |
+            (1 << (CypherParser.DROP - 54)) |
+            (1 << (CypherParser.INDEX - 54)) |
+            (1 << (CypherParser.ON - 54)) |
+            (1 << (CypherParser.CONSTRAINT - 54)) |
+            (1 << (CypherParser.ASSERT - 54)) |
+            (1 << (CypherParser.IS - 54)) |
+            (1 << (CypherParser.UNIQUE - 54)) |
+            (1 << (CypherParser.EXISTS - 54)) |
+            (1 << (CypherParser.LOAD - 54)) |
+            (1 << (CypherParser.CSV - 54)) |
+            (1 << (CypherParser.WITH - 54)) |
+            (1 << (CypherParser.HEADERS - 54)) |
+            (1 << (CypherParser.FROM - 54)) |
+            (1 << (CypherParser.AS - 54)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
+            (1 << (CypherParser.OPTIONAL - 54)) |
+            (1 << (CypherParser.MATCH - 54)) |
+            (1 << (CypherParser.UNWIND - 54)) |
+            (1 << (CypherParser.MERGE - 54)) |
+            (1 << (CypherParser.SET - 54)) |
+            (1 << (CypherParser.DETACH - 54)) |
+            (1 << (CypherParser.DELETE - 54)) |
+            (1 << (CypherParser.REMOVE - 54)))) !==
+          0) ||
+      (((_la - 86) & ~0x1f) == 0 &&
+        ((1 << (_la - 86)) &
+          ((1 << (CypherParser.FOREACH - 86)) |
+            (1 << (CypherParser.IN - 86)) |
+            (1 << (CypherParser.DISTINCT - 86)) |
+            (1 << (CypherParser.RETURN - 86)) |
+            (1 << (CypherParser.ORDER - 86)) |
+            (1 << (CypherParser.BY - 86)) |
+            (1 << (CypherParser.L_SKIP - 86)) |
+            (1 << (CypherParser.LIMIT - 86)) |
+            (1 << (CypherParser.ASCENDING - 86)) |
+            (1 << (CypherParser.ASC - 86)) |
+            (1 << (CypherParser.DESCENDING - 86)) |
+            (1 << (CypherParser.DESC - 86)) |
+            (1 << (CypherParser.JOIN - 86)) |
+            (1 << (CypherParser.SCAN - 86)) |
+            (1 << (CypherParser.START - 86)) |
+            (1 << (CypherParser.NODE - 86)) |
+            (1 << (CypherParser.RELATIONSHIP - 86)) |
+            (1 << (CypherParser.REL - 86)) |
+            (1 << (CypherParser.WHERE - 86)) |
+            (1 << (CypherParser.SHORTESTPATH - 86)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
+            (1 << (CypherParser.OR - 86)) |
+            (1 << (CypherParser.XOR - 86)) |
+            (1 << (CypherParser.AND - 86)) |
+            (1 << (CypherParser.NOT - 86)) |
+            (1 << (CypherParser.STARTS - 86)) |
+            (1 << (CypherParser.ENDS - 86)) |
+            (1 << (CypherParser.CONTAINS - 86)) |
+            (1 << (CypherParser.NULL - 86)) |
+            (1 << (CypherParser.COUNT - 86)) |
+            (1 << (CypherParser.FILTER - 86)) |
+            (1 << (CypherParser.EXTRACT - 86)))) !==
+          0) ||
+      (((_la - 118) & ~0x1f) == 0 &&
+        ((1 << (_la - 118)) &
+          ((1 << (CypherParser.ANY - 118)) |
+            (1 << (CypherParser.NONE - 118)) |
+            (1 << (CypherParser.SINGLE - 118)) |
+            (1 << (CypherParser.TRUE - 118)) |
+            (1 << (CypherParser.FALSE - 118)) |
+            (1 << (CypherParser.REDUCE - 118)) |
+            (1 << (CypherParser.CASE - 118)) |
+            (1 << (CypherParser.ELSE - 118)) |
+            (1 << (CypherParser.END - 118)) |
+            (1 << (CypherParser.WHEN - 118)) |
+            (1 << (CypherParser.THEN - 118)) |
+            (1 << (CypherParser.CALL - 118)) |
+            (1 << (CypherParser.YIELD - 118)) |
+            (1 << (CypherParser.KEY - 118)) |
+            (1 << (CypherParser.HexLetter - 118)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
+          0) ||
+      _la === CypherParser.EscapedSymbolicName
+    ) {
+      this.state = 2417
+      this.variable()
+      this.state = 2419
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2418
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2421
+      this.match(CypherParser.T__11)
+      this.state = 2423
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2422
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 2427
+    this.relationshipsPattern()
+    this.state = 2429
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2428
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2439
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.WHERE) {
+      this.state = 2431
+      this.match(CypherParser.WHERE)
+      this.state = 2433
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2432
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2435
+      this.expression()
+      this.state = 2437
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2436
+        this.match(CypherParser.SP)
+      }
+    }
+
+    this.state = 2441
+    this.match(CypherParser.T__21)
+    this.state = 2443
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2442
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2445
+    this.expression()
+    this.state = 2447
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2446
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2449
+    this.match(CypherParser.T__17)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertyLookupContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_propertyLookup
+  return this
+}
+
+PropertyLookupContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PropertyLookupContext.prototype.constructor = PropertyLookupContext
+
+PropertyLookupContext.prototype.propertyKeyName = function() {
+  return this.getTypedRuleContext(PropertyKeyNameContext, 0)
+}
+
+PropertyLookupContext.prototype.SP = function() {
+  return this.getToken(CypherParser.SP, 0)
+}
+
+PropertyLookupContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPropertyLookup(this)
+  }
+}
+
+PropertyLookupContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPropertyLookup(this)
+  }
+}
+
+CypherParser.PropertyLookupContext = PropertyLookupContext
+
+CypherParser.prototype.propertyLookup = function() {
+  var localctx = new PropertyLookupContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 350, CypherParser.RULE_propertyLookup)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2451
+    this.match(CypherParser.T__6)
+    this.state = 2453
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2452
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2455
+    this.propertyKeyName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CaseExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_caseExpression
+  return this
+}
+
+CaseExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CaseExpressionContext.prototype.constructor = CaseExpressionContext
+
+CaseExpressionContext.prototype.END = function() {
+  return this.getToken(CypherParser.END, 0)
+}
+
+CaseExpressionContext.prototype.ELSE = function() {
+  return this.getToken(CypherParser.ELSE, 0)
+}
+
+CaseExpressionContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+CaseExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+CaseExpressionContext.prototype.CASE = function() {
+  return this.getToken(CypherParser.CASE, 0)
+}
+
+CaseExpressionContext.prototype.caseAlternatives = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(CaseAlternativesContext)
+  } else {
+    return this.getTypedRuleContext(CaseAlternativesContext, i)
+  }
+}
+
+CaseExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCaseExpression(this)
+  }
+}
+
+CaseExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCaseExpression(this)
+  }
+}
+
+CypherParser.CaseExpressionContext = CaseExpressionContext
+
+CypherParser.prototype.caseExpression = function() {
+  var localctx = new CaseExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 352, CypherParser.RULE_caseExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2479
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 381, this._ctx)
+    switch (la_) {
+      case 1:
+        this.state = 2457
+        this.match(CypherParser.CASE)
+        this.state = 2462
+        this._errHandler.sync(this)
+        var _alt = 1
+        do {
+          switch (_alt) {
+            case 1:
+              this.state = 2459
+              this._errHandler.sync(this)
+              _la = this._input.LA(1)
+              if (_la === CypherParser.SP) {
+                this.state = 2458
+                this.match(CypherParser.SP)
+              }
+
+              this.state = 2461
+              this.caseAlternatives()
+              break
+            default:
+              throw new antlr4.error.NoViableAltException(this)
+          }
+          this.state = 2464
+          this._errHandler.sync(this)
+          _alt = this._interp.adaptivePredict(this._input, 377, this._ctx)
+        } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
+        break
+
+      case 2:
+        this.state = 2466
+        this.match(CypherParser.CASE)
+        this.state = 2468
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2467
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2470
+        this.expression()
+        this.state = 2475
+        this._errHandler.sync(this)
+        var _alt = 1
+        do {
+          switch (_alt) {
+            case 1:
+              this.state = 2472
+              this._errHandler.sync(this)
+              _la = this._input.LA(1)
+              if (_la === CypherParser.SP) {
+                this.state = 2471
+                this.match(CypherParser.SP)
+              }
+
+              this.state = 2474
+              this.caseAlternatives()
+              break
+            default:
+              throw new antlr4.error.NoViableAltException(this)
+          }
+          this.state = 2477
+          this._errHandler.sync(this)
+          _alt = this._interp.adaptivePredict(this._input, 380, this._ctx)
+        } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
+        break
+    }
+    this.state = 2489
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 384, this._ctx)
+    if (la_ === 1) {
+      this.state = 2482
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2481
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2484
+      this.match(CypherParser.ELSE)
+      this.state = 2486
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2485
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2488
+      this.expression()
+    }
+    this.state = 2492
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2491
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2494
+    this.match(CypherParser.END)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function CaseAlternativesContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_caseAlternatives
+  return this
+}
+
+CaseAlternativesContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+CaseAlternativesContext.prototype.constructor = CaseAlternativesContext
+
+CaseAlternativesContext.prototype.WHEN = function() {
+  return this.getToken(CypherParser.WHEN, 0)
+}
+
+CaseAlternativesContext.prototype.expression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(ExpressionContext)
+  } else {
+    return this.getTypedRuleContext(ExpressionContext, i)
+  }
+}
+
+CaseAlternativesContext.prototype.THEN = function() {
+  return this.getToken(CypherParser.THEN, 0)
+}
+
+CaseAlternativesContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+CaseAlternativesContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterCaseAlternatives(this)
+  }
+}
+
+CaseAlternativesContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitCaseAlternatives(this)
+  }
+}
+
+CypherParser.CaseAlternativesContext = CaseAlternativesContext
+
+CypherParser.prototype.caseAlternatives = function() {
+  var localctx = new CaseAlternativesContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 354, CypherParser.RULE_caseAlternatives)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2496
+    this.match(CypherParser.WHEN)
+    this.state = 2498
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2497
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2500
+    this.expression()
+    this.state = 2502
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2501
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2504
+    this.match(CypherParser.THEN)
+    this.state = 2506
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2505
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2508
+    this.expression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function VariableContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_variable
+  return this
+}
+
+VariableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+VariableContext.prototype.constructor = VariableContext
+
+VariableContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+VariableContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterVariable(this)
+  }
+}
+
+VariableContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitVariable(this)
+  }
+}
+
+CypherParser.VariableContext = VariableContext
+
+CypherParser.prototype.variable = function() {
+  var localctx = new VariableContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 356, CypherParser.RULE_variable)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2510
+    this.symbolicName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NumberLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_numberLiteral
+  return this
+}
+
+NumberLiteralContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+NumberLiteralContext.prototype.constructor = NumberLiteralContext
+
+NumberLiteralContext.prototype.doubleLiteral = function() {
+  return this.getTypedRuleContext(DoubleLiteralContext, 0)
+}
+
+NumberLiteralContext.prototype.integerLiteral = function() {
+  return this.getTypedRuleContext(IntegerLiteralContext, 0)
+}
+
+NumberLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNumberLiteral(this)
+  }
+}
+
+NumberLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNumberLiteral(this)
+  }
+}
+
+CypherParser.NumberLiteralContext = NumberLiteralContext
+
+CypherParser.prototype.numberLiteral = function() {
+  var localctx = new NumberLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 358, CypherParser.RULE_numberLiteral)
+  try {
+    this.state = 2514
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.ExponentDecimalReal:
+      case CypherParser.RegularDecimalReal:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2512
+        this.doubleLiteral()
+        break
+      case CypherParser.HexInteger:
+      case CypherParser.DecimalInteger:
+      case CypherParser.OctalInteger:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2513
+        this.integerLiteral()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function MapLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_mapLiteral
+  return this
+}
+
+MapLiteralContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+MapLiteralContext.prototype.constructor = MapLiteralContext
+
+MapLiteralContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+MapLiteralContext.prototype.literalEntry = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(LiteralEntryContext)
+  } else {
+    return this.getTypedRuleContext(LiteralEntryContext, i)
+  }
+}
+
+MapLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterMapLiteral(this)
+  }
+}
+
+MapLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitMapLiteral(this)
+  }
+}
+
+CypherParser.MapLiteralContext = MapLiteralContext
+
+CypherParser.prototype.mapLiteral = function() {
+  var localctx = new MapLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 360, CypherParser.RULE_mapLiteral)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2516
+    this.match(CypherParser.T__13)
+    this.state = 2518
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2517
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2537
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      (((_la - 54) & ~0x1f) == 0 &&
+        ((1 << (_la - 54)) &
+          ((1 << (CypherParser.CYPHER - 54)) |
+            (1 << (CypherParser.EXPLAIN - 54)) |
+            (1 << (CypherParser.PROFILE - 54)) |
+            (1 << (CypherParser.USING - 54)) |
+            (1 << (CypherParser.PERIODIC - 54)) |
+            (1 << (CypherParser.COMMIT - 54)) |
+            (1 << (CypherParser.UNION - 54)) |
+            (1 << (CypherParser.ALL - 54)) |
+            (1 << (CypherParser.CREATE - 54)) |
+            (1 << (CypherParser.DROP - 54)) |
+            (1 << (CypherParser.INDEX - 54)) |
+            (1 << (CypherParser.ON - 54)) |
+            (1 << (CypherParser.CONSTRAINT - 54)) |
+            (1 << (CypherParser.ASSERT - 54)) |
+            (1 << (CypherParser.IS - 54)) |
+            (1 << (CypherParser.UNIQUE - 54)) |
+            (1 << (CypherParser.EXISTS - 54)) |
+            (1 << (CypherParser.LOAD - 54)) |
+            (1 << (CypherParser.CSV - 54)) |
+            (1 << (CypherParser.WITH - 54)) |
+            (1 << (CypherParser.HEADERS - 54)) |
+            (1 << (CypherParser.FROM - 54)) |
+            (1 << (CypherParser.AS - 54)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
+            (1 << (CypherParser.OPTIONAL - 54)) |
+            (1 << (CypherParser.MATCH - 54)) |
+            (1 << (CypherParser.UNWIND - 54)) |
+            (1 << (CypherParser.MERGE - 54)) |
+            (1 << (CypherParser.SET - 54)) |
+            (1 << (CypherParser.DETACH - 54)) |
+            (1 << (CypherParser.DELETE - 54)) |
+            (1 << (CypherParser.REMOVE - 54)))) !==
+          0) ||
+      (((_la - 86) & ~0x1f) == 0 &&
+        ((1 << (_la - 86)) &
+          ((1 << (CypherParser.FOREACH - 86)) |
+            (1 << (CypherParser.IN - 86)) |
+            (1 << (CypherParser.DISTINCT - 86)) |
+            (1 << (CypherParser.RETURN - 86)) |
+            (1 << (CypherParser.ORDER - 86)) |
+            (1 << (CypherParser.BY - 86)) |
+            (1 << (CypherParser.L_SKIP - 86)) |
+            (1 << (CypherParser.LIMIT - 86)) |
+            (1 << (CypherParser.ASCENDING - 86)) |
+            (1 << (CypherParser.ASC - 86)) |
+            (1 << (CypherParser.DESCENDING - 86)) |
+            (1 << (CypherParser.DESC - 86)) |
+            (1 << (CypherParser.JOIN - 86)) |
+            (1 << (CypherParser.SCAN - 86)) |
+            (1 << (CypherParser.START - 86)) |
+            (1 << (CypherParser.NODE - 86)) |
+            (1 << (CypherParser.RELATIONSHIP - 86)) |
+            (1 << (CypherParser.REL - 86)) |
+            (1 << (CypherParser.WHERE - 86)) |
+            (1 << (CypherParser.SHORTESTPATH - 86)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
+            (1 << (CypherParser.OR - 86)) |
+            (1 << (CypherParser.XOR - 86)) |
+            (1 << (CypherParser.AND - 86)) |
+            (1 << (CypherParser.NOT - 86)) |
+            (1 << (CypherParser.STARTS - 86)) |
+            (1 << (CypherParser.ENDS - 86)) |
+            (1 << (CypherParser.CONTAINS - 86)) |
+            (1 << (CypherParser.NULL - 86)) |
+            (1 << (CypherParser.COUNT - 86)) |
+            (1 << (CypherParser.FILTER - 86)) |
+            (1 << (CypherParser.EXTRACT - 86)))) !==
+          0) ||
+      (((_la - 118) & ~0x1f) == 0 &&
+        ((1 << (_la - 118)) &
+          ((1 << (CypherParser.ANY - 118)) |
+            (1 << (CypherParser.NONE - 118)) |
+            (1 << (CypherParser.SINGLE - 118)) |
+            (1 << (CypherParser.TRUE - 118)) |
+            (1 << (CypherParser.FALSE - 118)) |
+            (1 << (CypherParser.REDUCE - 118)) |
+            (1 << (CypherParser.CASE - 118)) |
+            (1 << (CypherParser.ELSE - 118)) |
+            (1 << (CypherParser.END - 118)) |
+            (1 << (CypherParser.WHEN - 118)) |
+            (1 << (CypherParser.THEN - 118)) |
+            (1 << (CypherParser.CALL - 118)) |
+            (1 << (CypherParser.YIELD - 118)) |
+            (1 << (CypherParser.KEY - 118)) |
+            (1 << (CypherParser.HexLetter - 118)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
+          0) ||
+      _la === CypherParser.EscapedSymbolicName
+    ) {
+      this.state = 2520
+      this.literalEntry()
+      this.state = 2522
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      if (_la === CypherParser.SP) {
+        this.state = 2521
+        this.match(CypherParser.SP)
+      }
+
+      this.state = 2534
+      this._errHandler.sync(this)
+      _la = this._input.LA(1)
+      while (_la === CypherParser.T__14) {
+        this.state = 2524
+        this.match(CypherParser.T__14)
+        this.state = 2526
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2525
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2528
+        this.literalEntry()
+        this.state = 2530
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2529
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2536
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+      }
+    }
+
+    this.state = 2539
+    this.match(CypherParser.T__15)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function MapProjectionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_mapProjection
+  return this
+}
+
+MapProjectionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+MapProjectionContext.prototype.constructor = MapProjectionContext
+
+MapProjectionContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+MapProjectionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+MapProjectionContext.prototype.mapProjectionVariants = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(MapProjectionVariantsContext)
+  } else {
+    return this.getTypedRuleContext(MapProjectionVariantsContext, i)
+  }
+}
+
+MapProjectionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterMapProjection(this)
+  }
+}
+
+MapProjectionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitMapProjection(this)
+  }
+}
+
+CypherParser.MapProjectionContext = MapProjectionContext
+
+CypherParser.prototype.mapProjection = function() {
+  var localctx = new MapProjectionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 362, CypherParser.RULE_mapProjection)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2541
+    this.variable()
+    this.state = 2543
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2542
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2545
+    this.match(CypherParser.T__13)
+    this.state = 2547
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 397, this._ctx)
+    if (la_ === 1) {
+      this.state = 2546
+      this.match(CypherParser.SP)
+    }
+    this.state = 2550
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (
+      _la === CypherParser.T__6 ||
+      (((_la - 54) & ~0x1f) == 0 &&
+        ((1 << (_la - 54)) &
+          ((1 << (CypherParser.CYPHER - 54)) |
+            (1 << (CypherParser.EXPLAIN - 54)) |
+            (1 << (CypherParser.PROFILE - 54)) |
+            (1 << (CypherParser.USING - 54)) |
+            (1 << (CypherParser.PERIODIC - 54)) |
+            (1 << (CypherParser.COMMIT - 54)) |
+            (1 << (CypherParser.UNION - 54)) |
+            (1 << (CypherParser.ALL - 54)) |
+            (1 << (CypherParser.CREATE - 54)) |
+            (1 << (CypherParser.DROP - 54)) |
+            (1 << (CypherParser.INDEX - 54)) |
+            (1 << (CypherParser.ON - 54)) |
+            (1 << (CypherParser.CONSTRAINT - 54)) |
+            (1 << (CypherParser.ASSERT - 54)) |
+            (1 << (CypherParser.IS - 54)) |
+            (1 << (CypherParser.UNIQUE - 54)) |
+            (1 << (CypherParser.EXISTS - 54)) |
+            (1 << (CypherParser.LOAD - 54)) |
+            (1 << (CypherParser.CSV - 54)) |
+            (1 << (CypherParser.WITH - 54)) |
+            (1 << (CypherParser.HEADERS - 54)) |
+            (1 << (CypherParser.FROM - 54)) |
+            (1 << (CypherParser.AS - 54)) |
+            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
+            (1 << (CypherParser.OPTIONAL - 54)) |
+            (1 << (CypherParser.MATCH - 54)) |
+            (1 << (CypherParser.UNWIND - 54)) |
+            (1 << (CypherParser.MERGE - 54)) |
+            (1 << (CypherParser.SET - 54)) |
+            (1 << (CypherParser.DETACH - 54)) |
+            (1 << (CypherParser.DELETE - 54)) |
+            (1 << (CypherParser.REMOVE - 54)))) !==
+          0) ||
+      (((_la - 86) & ~0x1f) == 0 &&
+        ((1 << (_la - 86)) &
+          ((1 << (CypherParser.FOREACH - 86)) |
+            (1 << (CypherParser.IN - 86)) |
+            (1 << (CypherParser.DISTINCT - 86)) |
+            (1 << (CypherParser.RETURN - 86)) |
+            (1 << (CypherParser.ORDER - 86)) |
+            (1 << (CypherParser.BY - 86)) |
+            (1 << (CypherParser.L_SKIP - 86)) |
+            (1 << (CypherParser.LIMIT - 86)) |
+            (1 << (CypherParser.ASCENDING - 86)) |
+            (1 << (CypherParser.ASC - 86)) |
+            (1 << (CypherParser.DESCENDING - 86)) |
+            (1 << (CypherParser.DESC - 86)) |
+            (1 << (CypherParser.JOIN - 86)) |
+            (1 << (CypherParser.SCAN - 86)) |
+            (1 << (CypherParser.START - 86)) |
+            (1 << (CypherParser.NODE - 86)) |
+            (1 << (CypherParser.RELATIONSHIP - 86)) |
+            (1 << (CypherParser.REL - 86)) |
+            (1 << (CypherParser.WHERE - 86)) |
+            (1 << (CypherParser.SHORTESTPATH - 86)) |
+            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
+            (1 << (CypherParser.OR - 86)) |
+            (1 << (CypherParser.XOR - 86)) |
+            (1 << (CypherParser.AND - 86)) |
+            (1 << (CypherParser.NOT - 86)) |
+            (1 << (CypherParser.STARTS - 86)) |
+            (1 << (CypherParser.ENDS - 86)) |
+            (1 << (CypherParser.CONTAINS - 86)) |
+            (1 << (CypherParser.NULL - 86)) |
+            (1 << (CypherParser.COUNT - 86)) |
+            (1 << (CypherParser.FILTER - 86)) |
+            (1 << (CypherParser.EXTRACT - 86)))) !==
+          0) ||
+      (((_la - 118) & ~0x1f) == 0 &&
+        ((1 << (_la - 118)) &
+          ((1 << (CypherParser.ANY - 118)) |
+            (1 << (CypherParser.NONE - 118)) |
+            (1 << (CypherParser.SINGLE - 118)) |
+            (1 << (CypherParser.TRUE - 118)) |
+            (1 << (CypherParser.FALSE - 118)) |
+            (1 << (CypherParser.REDUCE - 118)) |
+            (1 << (CypherParser.CASE - 118)) |
+            (1 << (CypherParser.ELSE - 118)) |
+            (1 << (CypherParser.END - 118)) |
+            (1 << (CypherParser.WHEN - 118)) |
+            (1 << (CypherParser.THEN - 118)) |
+            (1 << (CypherParser.CALL - 118)) |
+            (1 << (CypherParser.YIELD - 118)) |
+            (1 << (CypherParser.KEY - 118)) |
+            (1 << (CypherParser.HexLetter - 118)) |
+            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
+          0) ||
+      _la === CypherParser.EscapedSymbolicName
+    ) {
+      this.state = 2549
+      this.mapProjectionVariants()
+    }
+
+    this.state = 2562
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 401, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 2553
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2552
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2555
+        this.match(CypherParser.T__14)
+        this.state = 2557
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2556
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2559
+        this.mapProjectionVariants()
+      }
+      this.state = 2564
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 401, this._ctx)
+    }
+
+    this.state = 2566
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2565
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2568
+    this.match(CypherParser.T__15)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function MapProjectionVariantsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_mapProjectionVariants
+  return this
+}
+
+MapProjectionVariantsContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+MapProjectionVariantsContext.prototype.constructor = MapProjectionVariantsContext
+
+MapProjectionVariantsContext.prototype.literalEntry = function() {
+  return this.getTypedRuleContext(LiteralEntryContext, 0)
+}
+
+MapProjectionVariantsContext.prototype.propertySelector = function() {
+  return this.getTypedRuleContext(PropertySelectorContext, 0)
+}
+
+MapProjectionVariantsContext.prototype.variableSelector = function() {
+  return this.getTypedRuleContext(VariableSelectorContext, 0)
+}
+
+MapProjectionVariantsContext.prototype.allPropertiesSelector = function() {
+  return this.getTypedRuleContext(AllPropertiesSelectorContext, 0)
+}
+
+MapProjectionVariantsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterMapProjectionVariants(this)
+  }
+}
+
+MapProjectionVariantsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitMapProjectionVariants(this)
+  }
+}
+
+CypherParser.MapProjectionVariantsContext = MapProjectionVariantsContext
+
+CypherParser.prototype.mapProjectionVariants = function() {
+  var localctx = new MapProjectionVariantsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 364, CypherParser.RULE_mapProjectionVariants)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2574
+    this._errHandler.sync(this)
+    var la_ = this._interp.adaptivePredict(this._input, 403, this._ctx)
+    switch (la_) {
+      case 1:
+        this.state = 2570
+        this.literalEntry()
+        break
+
+      case 2:
+        this.state = 2571
+        this.propertySelector()
+        break
+
+      case 3:
+        this.state = 2572
+        this.variableSelector()
+        break
+
+      case 4:
+        this.state = 2573
+        this.allPropertiesSelector()
+        break
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LiteralEntryContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_literalEntry
+  return this
+}
+
+LiteralEntryContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+LiteralEntryContext.prototype.constructor = LiteralEntryContext
+
+LiteralEntryContext.prototype.propertyKeyName = function() {
+  return this.getTypedRuleContext(PropertyKeyNameContext, 0)
+}
+
+LiteralEntryContext.prototype.expression = function() {
+  return this.getTypedRuleContext(ExpressionContext, 0)
+}
+
+LiteralEntryContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+LiteralEntryContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLiteralEntry(this)
+  }
+}
+
+LiteralEntryContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLiteralEntry(this)
+  }
+}
+
+CypherParser.LiteralEntryContext = LiteralEntryContext
+
+CypherParser.prototype.literalEntry = function() {
+  var localctx = new LiteralEntryContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 366, CypherParser.RULE_literalEntry)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2576
+    this.propertyKeyName()
+    this.state = 2578
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2577
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2580
+    this.match(CypherParser.T__1)
+    this.state = 2582
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2581
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2584
+    this.expression()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertySelectorContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_propertySelector
+  return this
+}
+
+PropertySelectorContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PropertySelectorContext.prototype.constructor = PropertySelectorContext
+
+PropertySelectorContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+PropertySelectorContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPropertySelector(this)
+  }
+}
+
+PropertySelectorContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPropertySelector(this)
+  }
+}
+
+CypherParser.PropertySelectorContext = PropertySelectorContext
+
+CypherParser.prototype.propertySelector = function() {
+  var localctx = new PropertySelectorContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 368, CypherParser.RULE_propertySelector)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2586
+    this.match(CypherParser.T__6)
+    this.state = 2587
+    this.variable()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function VariableSelectorContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_variableSelector
+  return this
+}
+
+VariableSelectorContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+VariableSelectorContext.prototype.constructor = VariableSelectorContext
+
+VariableSelectorContext.prototype.variable = function() {
+  return this.getTypedRuleContext(VariableContext, 0)
+}
+
+VariableSelectorContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterVariableSelector(this)
+  }
+}
+
+VariableSelectorContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitVariableSelector(this)
+  }
+}
+
+CypherParser.VariableSelectorContext = VariableSelectorContext
+
+CypherParser.prototype.variableSelector = function() {
+  var localctx = new VariableSelectorContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 370, CypherParser.RULE_variableSelector)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2589
+    this.variable()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function AllPropertiesSelectorContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_allPropertiesSelector
+  return this
+}
+
+AllPropertiesSelectorContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+AllPropertiesSelectorContext.prototype.constructor = AllPropertiesSelectorContext
+
+AllPropertiesSelectorContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterAllPropertiesSelector(this)
+  }
+}
+
+AllPropertiesSelectorContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitAllPropertiesSelector(this)
+  }
+}
+
+CypherParser.AllPropertiesSelectorContext = AllPropertiesSelectorContext
+
+CypherParser.prototype.allPropertiesSelector = function() {
+  var localctx = new AllPropertiesSelectorContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 372, CypherParser.RULE_allPropertiesSelector)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2591
+    this.match(CypherParser.T__6)
+    this.state = 2592
+    this.match(CypherParser.T__22)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ParameterContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_parameter
+  return this
+}
+
+ParameterContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+ParameterContext.prototype.constructor = ParameterContext
+
+ParameterContext.prototype.legacyParameter = function() {
+  return this.getTypedRuleContext(LegacyParameterContext, 0)
+}
+
+ParameterContext.prototype.newParameter = function() {
+  return this.getTypedRuleContext(NewParameterContext, 0)
+}
+
+ParameterContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterParameter(this)
+  }
+}
+
+ParameterContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitParameter(this)
+  }
+}
+
+CypherParser.ParameterContext = ParameterContext
+
+CypherParser.prototype.parameter = function() {
+  var localctx = new ParameterContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 374, CypherParser.RULE_parameter)
+  try {
+    this.state = 2596
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.T__13:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2594
+        this.legacyParameter()
+        break
+      case CypherParser.T__33:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2595
+        this.newParameter()
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LegacyParameterContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_legacyParameter
+  return this
+}
+
+LegacyParameterContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+LegacyParameterContext.prototype.constructor = LegacyParameterContext
+
+LegacyParameterContext.prototype.parameterName = function() {
+  return this.getTypedRuleContext(ParameterNameContext, 0)
+}
+
+LegacyParameterContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+LegacyParameterContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLegacyParameter(this)
+  }
+}
+
+LegacyParameterContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLegacyParameter(this)
+  }
+}
+
+CypherParser.LegacyParameterContext = LegacyParameterContext
+
+CypherParser.prototype.legacyParameter = function() {
+  var localctx = new LegacyParameterContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 376, CypherParser.RULE_legacyParameter)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2598
+    this.match(CypherParser.T__13)
+    this.state = 2600
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2599
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2602
+    this.parameterName()
+    this.state = 2604
+    this._errHandler.sync(this)
+    _la = this._input.LA(1)
+    if (_la === CypherParser.SP) {
+      this.state = 2603
+      this.match(CypherParser.SP)
+    }
+
+    this.state = 2606
+    this.match(CypherParser.T__15)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NewParameterContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_newParameter
+  return this
+}
+
+NewParameterContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+NewParameterContext.prototype.constructor = NewParameterContext
+
+NewParameterContext.prototype.parameterName = function() {
+  return this.getTypedRuleContext(ParameterNameContext, 0)
+}
+
+NewParameterContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNewParameter(this)
+  }
+}
+
+NewParameterContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNewParameter(this)
+  }
+}
+
+CypherParser.NewParameterContext = NewParameterContext
+
+CypherParser.prototype.newParameter = function() {
+  var localctx = new NewParameterContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 378, CypherParser.RULE_newParameter)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2608
+    this.match(CypherParser.T__33)
+    this.state = 2609
+    this.parameterName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function ParameterNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_parameterName
+  return this
+}
+
+ParameterNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+ParameterNameContext.prototype.constructor = ParameterNameContext
+
+ParameterNameContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+ParameterNameContext.prototype.DecimalInteger = function() {
+  return this.getToken(CypherParser.DecimalInteger, 0)
+}
+
+ParameterNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterParameterName(this)
+  }
+}
+
+ParameterNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitParameterName(this)
+  }
+}
+
+CypherParser.ParameterNameContext = ParameterNameContext
+
+CypherParser.prototype.parameterName = function() {
+  var localctx = new ParameterNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 380, CypherParser.RULE_parameterName)
+  try {
+    this.state = 2613
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.CYPHER:
+      case CypherParser.EXPLAIN:
+      case CypherParser.PROFILE:
+      case CypherParser.USING:
+      case CypherParser.PERIODIC:
+      case CypherParser.COMMIT:
+      case CypherParser.UNION:
+      case CypherParser.ALL:
+      case CypherParser.CREATE:
+      case CypherParser.DROP:
+      case CypherParser.INDEX:
+      case CypherParser.ON:
+      case CypherParser.CONSTRAINT:
+      case CypherParser.ASSERT:
+      case CypherParser.IS:
+      case CypherParser.UNIQUE:
+      case CypherParser.EXISTS:
+      case CypherParser.LOAD:
+      case CypherParser.CSV:
+      case CypherParser.WITH:
+      case CypherParser.HEADERS:
+      case CypherParser.FROM:
+      case CypherParser.AS:
+      case CypherParser.FIELDTERMINATOR:
+      case CypherParser.OPTIONAL:
+      case CypherParser.MATCH:
+      case CypherParser.UNWIND:
+      case CypherParser.MERGE:
+      case CypherParser.SET:
+      case CypherParser.DETACH:
+      case CypherParser.DELETE:
+      case CypherParser.REMOVE:
+      case CypherParser.FOREACH:
+      case CypherParser.IN:
+      case CypherParser.DISTINCT:
+      case CypherParser.RETURN:
+      case CypherParser.ORDER:
+      case CypherParser.BY:
+      case CypherParser.L_SKIP:
+      case CypherParser.LIMIT:
+      case CypherParser.ASCENDING:
+      case CypherParser.ASC:
+      case CypherParser.DESCENDING:
+      case CypherParser.DESC:
+      case CypherParser.JOIN:
+      case CypherParser.SCAN:
+      case CypherParser.START:
+      case CypherParser.NODE:
+      case CypherParser.RELATIONSHIP:
+      case CypherParser.REL:
+      case CypherParser.WHERE:
+      case CypherParser.SHORTESTPATH:
+      case CypherParser.ALLSHORTESTPATHS:
+      case CypherParser.OR:
+      case CypherParser.XOR:
+      case CypherParser.AND:
+      case CypherParser.NOT:
+      case CypherParser.STARTS:
+      case CypherParser.ENDS:
+      case CypherParser.CONTAINS:
+      case CypherParser.NULL:
+      case CypherParser.COUNT:
+      case CypherParser.FILTER:
+      case CypherParser.EXTRACT:
+      case CypherParser.ANY:
+      case CypherParser.NONE:
+      case CypherParser.SINGLE:
+      case CypherParser.TRUE:
+      case CypherParser.FALSE:
+      case CypherParser.REDUCE:
+      case CypherParser.CASE:
+      case CypherParser.ELSE:
+      case CypherParser.END:
+      case CypherParser.WHEN:
+      case CypherParser.THEN:
+      case CypherParser.CALL:
+      case CypherParser.YIELD:
+      case CypherParser.KEY:
+      case CypherParser.HexLetter:
+      case CypherParser.UnescapedSymbolicName:
+      case CypherParser.EscapedSymbolicName:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2611
+        this.symbolicName()
+        break
+      case CypherParser.DecimalInteger:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2612
+        this.match(CypherParser.DecimalInteger)
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertyExpressionsContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_propertyExpressions
+  return this
+}
+
+PropertyExpressionsContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PropertyExpressionsContext.prototype.constructor = PropertyExpressionsContext
+
+PropertyExpressionsContext.prototype.propertyExpression = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PropertyExpressionContext)
+  } else {
+    return this.getTypedRuleContext(PropertyExpressionContext, i)
+  }
+}
+
+PropertyExpressionsContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PropertyExpressionsContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPropertyExpressions(this)
+  }
+}
+
+PropertyExpressionsContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPropertyExpressions(this)
+  }
+}
+
+CypherParser.PropertyExpressionsContext = PropertyExpressionsContext
+
+CypherParser.prototype.propertyExpressions = function() {
+  var localctx = new PropertyExpressionsContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 382, CypherParser.RULE_propertyExpressions)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2615
+    this.propertyExpression()
+    this.state = 2626
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 412, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 2617
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2616
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2619
+        this.match(CypherParser.T__14)
+        this.state = 2621
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2620
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2623
+        this.propertyExpression()
+      }
+      this.state = 2628
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 412, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertyExpressionContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_propertyExpression
+  return this
+}
+
+PropertyExpressionContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PropertyExpressionContext.prototype.constructor = PropertyExpressionContext
+
+PropertyExpressionContext.prototype.atom = function() {
+  return this.getTypedRuleContext(AtomContext, 0)
+}
+
+PropertyExpressionContext.prototype.propertyLookup = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PropertyLookupContext)
+  } else {
+    return this.getTypedRuleContext(PropertyLookupContext, i)
+  }
+}
+
+PropertyExpressionContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PropertyExpressionContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPropertyExpression(this)
+  }
+}
+
+PropertyExpressionContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPropertyExpression(this)
+  }
+}
+
+CypherParser.PropertyExpressionContext = PropertyExpressionContext
+
+CypherParser.prototype.propertyExpression = function() {
+  var localctx = new PropertyExpressionContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 384, CypherParser.RULE_propertyExpression)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2629
+    this.atom()
+    this.state = 2634
+    this._errHandler.sync(this)
+    var _alt = 1
+    do {
+      switch (_alt) {
+        case 1:
+          this.state = 2631
+          this._errHandler.sync(this)
+          _la = this._input.LA(1)
+          if (_la === CypherParser.SP) {
+            this.state = 2630
+            this.match(CypherParser.SP)
+          }
+
+          this.state = 2633
+          this.propertyLookup()
+          break
+        default:
+          throw new antlr4.error.NoViableAltException(this)
+      }
+      this.state = 2636
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 414, this._ctx)
+    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertyKeysContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_propertyKeys
+  return this
+}
+
+PropertyKeysContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PropertyKeysContext.prototype.constructor = PropertyKeysContext
+
+PropertyKeysContext.prototype.propertyKeyName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(PropertyKeyNameContext)
+  } else {
+    return this.getTypedRuleContext(PropertyKeyNameContext, i)
+  }
+}
+
+PropertyKeysContext.prototype.SP = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTokens(CypherParser.SP)
+  } else {
+    return this.getToken(CypherParser.SP, i)
+  }
+}
+
+PropertyKeysContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPropertyKeys(this)
+  }
+}
+
+PropertyKeysContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPropertyKeys(this)
+  }
+}
+
+CypherParser.PropertyKeysContext = PropertyKeysContext
+
+CypherParser.prototype.propertyKeys = function() {
+  var localctx = new PropertyKeysContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 386, CypherParser.RULE_propertyKeys)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2638
+    this.propertyKeyName()
+    this.state = 2649
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 417, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 2640
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2639
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2642
+        this.match(CypherParser.T__14)
+        this.state = 2644
+        this._errHandler.sync(this)
+        _la = this._input.LA(1)
+        if (_la === CypherParser.SP) {
+          this.state = 2643
+          this.match(CypherParser.SP)
+        }
+
+        this.state = 2646
+        this.propertyKeyName()
+      }
+      this.state = 2651
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 417, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function PropertyKeyNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_propertyKeyName
+  return this
+}
+
+PropertyKeyNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+PropertyKeyNameContext.prototype.constructor = PropertyKeyNameContext
+
+PropertyKeyNameContext.prototype.symbolicName = function() {
+  return this.getTypedRuleContext(SymbolicNameContext, 0)
+}
+
+PropertyKeyNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterPropertyKeyName(this)
+  }
+}
+
+PropertyKeyNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitPropertyKeyName(this)
+  }
+}
+
+CypherParser.PropertyKeyNameContext = PropertyKeyNameContext
+
+CypherParser.prototype.propertyKeyName = function() {
+  var localctx = new PropertyKeyNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 388, CypherParser.RULE_propertyKeyName)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2652
+    this.symbolicName()
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function IntegerLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_integerLiteral
+  return this
+}
+
+IntegerLiteralContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+IntegerLiteralContext.prototype.constructor = IntegerLiteralContext
+
+IntegerLiteralContext.prototype.HexInteger = function() {
+  return this.getToken(CypherParser.HexInteger, 0)
+}
+
+IntegerLiteralContext.prototype.OctalInteger = function() {
+  return this.getToken(CypherParser.OctalInteger, 0)
+}
+
+IntegerLiteralContext.prototype.DecimalInteger = function() {
+  return this.getToken(CypherParser.DecimalInteger, 0)
+}
+
+IntegerLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterIntegerLiteral(this)
+  }
+}
+
+IntegerLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitIntegerLiteral(this)
+  }
+}
+
+CypherParser.IntegerLiteralContext = IntegerLiteralContext
+
+CypherParser.prototype.integerLiteral = function() {
+  var localctx = new IntegerLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 390, CypherParser.RULE_integerLiteral)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2654
+    _la = this._input.LA(1)
+    if (
+      !(
+        ((_la - 135) & ~0x1f) == 0 &&
+        ((1 << (_la - 135)) &
+          ((1 << (CypherParser.HexInteger - 135)) |
+            (1 << (CypherParser.DecimalInteger - 135)) |
+            (1 << (CypherParser.OctalInteger - 135)))) !==
+          0
+      )
+    ) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DoubleLiteralContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_doubleLiteral
+  return this
+}
+
+DoubleLiteralContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+DoubleLiteralContext.prototype.constructor = DoubleLiteralContext
+
+DoubleLiteralContext.prototype.ExponentDecimalReal = function() {
+  return this.getToken(CypherParser.ExponentDecimalReal, 0)
+}
+
+DoubleLiteralContext.prototype.RegularDecimalReal = function() {
+  return this.getToken(CypherParser.RegularDecimalReal, 0)
+}
+
+DoubleLiteralContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterDoubleLiteral(this)
+  }
+}
+
+DoubleLiteralContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitDoubleLiteral(this)
+  }
+}
+
+CypherParser.DoubleLiteralContext = DoubleLiteralContext
+
+CypherParser.prototype.doubleLiteral = function() {
+  var localctx = new DoubleLiteralContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 392, CypherParser.RULE_doubleLiteral)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2656
+    _la = this._input.LA(1)
+    if (
+      !(
+        _la === CypherParser.ExponentDecimalReal ||
+        _la === CypherParser.RegularDecimalReal
+      )
+    ) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function NamespaceContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_namespace
+  return this
+}
+
+NamespaceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+NamespaceContext.prototype.constructor = NamespaceContext
+
+NamespaceContext.prototype.symbolicName = function(i) {
+  if (i === undefined) {
+    i = null
+  }
+  if (i === null) {
+    return this.getTypedRuleContexts(SymbolicNameContext)
+  } else {
+    return this.getTypedRuleContext(SymbolicNameContext, i)
+  }
+}
+
+NamespaceContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterNamespace(this)
+  }
+}
+
+NamespaceContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitNamespace(this)
+  }
+}
+
+CypherParser.NamespaceContext = NamespaceContext
+
+CypherParser.prototype.namespace = function() {
+  var localctx = new NamespaceContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 394, CypherParser.RULE_namespace)
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2663
+    this._errHandler.sync(this)
+    var _alt = this._interp.adaptivePredict(this._input, 418, this._ctx)
+    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+      if (_alt === 1) {
+        this.state = 2658
+        this.symbolicName()
+        this.state = 2659
+        this.match(CypherParser.T__6)
+      }
+      this.state = 2665
+      this._errHandler.sync(this)
+      _alt = this._interp.adaptivePredict(this._input, 418, this._ctx)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function LeftArrowHeadContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_leftArrowHead
+  return this
+}
+
+LeftArrowHeadContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+LeftArrowHeadContext.prototype.constructor = LeftArrowHeadContext
+
+LeftArrowHeadContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterLeftArrowHead(this)
+  }
+}
+
+LeftArrowHeadContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitLeftArrowHead(this)
+  }
+}
+
+CypherParser.LeftArrowHeadContext = LeftArrowHeadContext
+
+CypherParser.prototype.leftArrowHead = function() {
+  var localctx = new LeftArrowHeadContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 396, CypherParser.RULE_leftArrowHead)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2666
+    _la = this._input.LA(1)
+    if (
+      !(
+        ((_la - 30) & ~0x1f) == 0 &&
+        ((1 << (_la - 30)) &
+          ((1 << (CypherParser.T__29 - 30)) |
+            (1 << (CypherParser.T__34 - 30)) |
+            (1 << (CypherParser.T__35 - 30)) |
+            (1 << (CypherParser.T__36 - 30)) |
+            (1 << (CypherParser.T__37 - 30)))) !==
+          0
+      )
+    ) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function RightArrowHeadContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_rightArrowHead
+  return this
+}
+
+RightArrowHeadContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+RightArrowHeadContext.prototype.constructor = RightArrowHeadContext
+
+RightArrowHeadContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterRightArrowHead(this)
+  }
+}
+
+RightArrowHeadContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitRightArrowHead(this)
+  }
+}
+
+CypherParser.RightArrowHeadContext = RightArrowHeadContext
+
+CypherParser.prototype.rightArrowHead = function() {
+  var localctx = new RightArrowHeadContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 398, CypherParser.RULE_rightArrowHead)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2668
+    _la = this._input.LA(1)
+    if (
+      !(
+        ((_la - 31) & ~0x1f) == 0 &&
+        ((1 << (_la - 31)) &
+          ((1 << (CypherParser.T__30 - 31)) |
+            (1 << (CypherParser.T__38 - 31)) |
+            (1 << (CypherParser.T__39 - 31)) |
+            (1 << (CypherParser.T__40 - 31)) |
+            (1 << (CypherParser.T__41 - 31)))) !==
+          0
+      )
+    ) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function DashContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_dash
+  return this
+}
+
+DashContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+DashContext.prototype.constructor = DashContext
+
+DashContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterDash(this)
+  }
+}
+
+DashContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitDash(this)
+  }
+}
+
+CypherParser.DashContext = DashContext
+
+CypherParser.prototype.dash = function() {
+  var localctx = new DashContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 400, CypherParser.RULE_dash)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2670
+    _la = this._input.LA(1)
+    if (
+      !(
+        _la === CypherParser.T__2 ||
+        (((_la - 43) & ~0x1f) == 0 &&
+          ((1 << (_la - 43)) &
+            ((1 << (CypherParser.T__42 - 43)) |
+              (1 << (CypherParser.T__43 - 43)) |
+              (1 << (CypherParser.T__44 - 43)) |
+              (1 << (CypherParser.T__45 - 43)) |
+              (1 << (CypherParser.T__46 - 43)) |
+              (1 << (CypherParser.T__47 - 43)) |
+              (1 << (CypherParser.T__48 - 43)) |
+              (1 << (CypherParser.T__49 - 43)) |
+              (1 << (CypherParser.T__50 - 43)) |
+              (1 << (CypherParser.T__51 - 43)) |
+              (1 << (CypherParser.T__52 - 43)))) !==
+            0)
+      )
+    ) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function SymbolicNameContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_symbolicName
+  return this
+}
+
+SymbolicNameContext.prototype = Object.create(
+  antlr4.ParserRuleContext.prototype
+)
+SymbolicNameContext.prototype.constructor = SymbolicNameContext
+
+SymbolicNameContext.prototype.keyword = function() {
+  return this.getTypedRuleContext(KeywordContext, 0)
+}
+
+SymbolicNameContext.prototype.UnescapedSymbolicName = function() {
+  return this.getToken(CypherParser.UnescapedSymbolicName, 0)
+}
+
+SymbolicNameContext.prototype.EscapedSymbolicName = function() {
+  return this.getToken(CypherParser.EscapedSymbolicName, 0)
+}
+
+SymbolicNameContext.prototype.HexLetter = function() {
+  return this.getToken(CypherParser.HexLetter, 0)
+}
+
+SymbolicNameContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterSymbolicName(this)
+  }
+}
+
+SymbolicNameContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitSymbolicName(this)
+  }
+}
+
+CypherParser.SymbolicNameContext = SymbolicNameContext
+
+CypherParser.prototype.symbolicName = function() {
+  var localctx = new SymbolicNameContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 402, CypherParser.RULE_symbolicName)
+  try {
+    this.state = 2676
+    this._errHandler.sync(this)
+    switch (this._input.LA(1)) {
+      case CypherParser.CYPHER:
+      case CypherParser.EXPLAIN:
+      case CypherParser.PROFILE:
+      case CypherParser.USING:
+      case CypherParser.PERIODIC:
+      case CypherParser.COMMIT:
+      case CypherParser.UNION:
+      case CypherParser.ALL:
+      case CypherParser.CREATE:
+      case CypherParser.DROP:
+      case CypherParser.INDEX:
+      case CypherParser.ON:
+      case CypherParser.CONSTRAINT:
+      case CypherParser.ASSERT:
+      case CypherParser.IS:
+      case CypherParser.UNIQUE:
+      case CypherParser.EXISTS:
+      case CypherParser.LOAD:
+      case CypherParser.CSV:
+      case CypherParser.WITH:
+      case CypherParser.HEADERS:
+      case CypherParser.FROM:
+      case CypherParser.AS:
+      case CypherParser.FIELDTERMINATOR:
+      case CypherParser.OPTIONAL:
+      case CypherParser.MATCH:
+      case CypherParser.UNWIND:
+      case CypherParser.MERGE:
+      case CypherParser.SET:
+      case CypherParser.DETACH:
+      case CypherParser.DELETE:
+      case CypherParser.REMOVE:
+      case CypherParser.FOREACH:
+      case CypherParser.IN:
+      case CypherParser.DISTINCT:
+      case CypherParser.RETURN:
+      case CypherParser.ORDER:
+      case CypherParser.BY:
+      case CypherParser.L_SKIP:
+      case CypherParser.LIMIT:
+      case CypherParser.ASCENDING:
+      case CypherParser.ASC:
+      case CypherParser.DESCENDING:
+      case CypherParser.DESC:
+      case CypherParser.JOIN:
+      case CypherParser.SCAN:
+      case CypherParser.START:
+      case CypherParser.NODE:
+      case CypherParser.RELATIONSHIP:
+      case CypherParser.REL:
+      case CypherParser.WHERE:
+      case CypherParser.SHORTESTPATH:
+      case CypherParser.ALLSHORTESTPATHS:
+      case CypherParser.OR:
+      case CypherParser.XOR:
+      case CypherParser.AND:
+      case CypherParser.NOT:
+      case CypherParser.STARTS:
+      case CypherParser.ENDS:
+      case CypherParser.CONTAINS:
+      case CypherParser.NULL:
+      case CypherParser.COUNT:
+      case CypherParser.FILTER:
+      case CypherParser.EXTRACT:
+      case CypherParser.ANY:
+      case CypherParser.NONE:
+      case CypherParser.SINGLE:
+      case CypherParser.TRUE:
+      case CypherParser.FALSE:
+      case CypherParser.REDUCE:
+      case CypherParser.CASE:
+      case CypherParser.ELSE:
+      case CypherParser.END:
+      case CypherParser.WHEN:
+      case CypherParser.THEN:
+      case CypherParser.CALL:
+      case CypherParser.YIELD:
+      case CypherParser.KEY:
+        this.enterOuterAlt(localctx, 1)
+        this.state = 2672
+        this.keyword()
+        break
+      case CypherParser.UnescapedSymbolicName:
+        this.enterOuterAlt(localctx, 2)
+        this.state = 2673
+        this.match(CypherParser.UnescapedSymbolicName)
+        break
+      case CypherParser.EscapedSymbolicName:
+        this.enterOuterAlt(localctx, 3)
+        this.state = 2674
+        this.match(CypherParser.EscapedSymbolicName)
+        break
+      case CypherParser.HexLetter:
+        this.enterOuterAlt(localctx, 4)
+        this.state = 2675
+        this.match(CypherParser.HexLetter)
+        break
+      default:
+        throw new antlr4.error.NoViableAltException(this)
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+function KeywordContext(parser, parent, invokingState) {
+  if (parent === undefined) {
+    parent = null
+  }
+  if (invokingState === undefined || invokingState === null) {
+    invokingState = -1
+  }
+  antlr4.ParserRuleContext.call(this, parent, invokingState)
+  this.parser = parser
+  this.ruleIndex = CypherParser.RULE_keyword
+  return this
+}
+
+KeywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
+KeywordContext.prototype.constructor = KeywordContext
+
+KeywordContext.prototype.CYPHER = function() {
+  return this.getToken(CypherParser.CYPHER, 0)
+}
+
+KeywordContext.prototype.EXPLAIN = function() {
+  return this.getToken(CypherParser.EXPLAIN, 0)
+}
+
+KeywordContext.prototype.PROFILE = function() {
+  return this.getToken(CypherParser.PROFILE, 0)
+}
+
+KeywordContext.prototype.USING = function() {
+  return this.getToken(CypherParser.USING, 0)
+}
+
+KeywordContext.prototype.PERIODIC = function() {
+  return this.getToken(CypherParser.PERIODIC, 0)
+}
+
+KeywordContext.prototype.COMMIT = function() {
+  return this.getToken(CypherParser.COMMIT, 0)
+}
+
+KeywordContext.prototype.UNION = function() {
+  return this.getToken(CypherParser.UNION, 0)
+}
+
+KeywordContext.prototype.ALL = function() {
+  return this.getToken(CypherParser.ALL, 0)
+}
+
+KeywordContext.prototype.CREATE = function() {
+  return this.getToken(CypherParser.CREATE, 0)
+}
+
+KeywordContext.prototype.DROP = function() {
+  return this.getToken(CypherParser.DROP, 0)
+}
+
+KeywordContext.prototype.INDEX = function() {
+  return this.getToken(CypherParser.INDEX, 0)
+}
+
+KeywordContext.prototype.ON = function() {
+  return this.getToken(CypherParser.ON, 0)
+}
+
+KeywordContext.prototype.CONSTRAINT = function() {
+  return this.getToken(CypherParser.CONSTRAINT, 0)
+}
+
+KeywordContext.prototype.ASSERT = function() {
+  return this.getToken(CypherParser.ASSERT, 0)
+}
+
+KeywordContext.prototype.IS = function() {
+  return this.getToken(CypherParser.IS, 0)
+}
+
+KeywordContext.prototype.UNIQUE = function() {
+  return this.getToken(CypherParser.UNIQUE, 0)
+}
+
+KeywordContext.prototype.EXISTS = function() {
+  return this.getToken(CypherParser.EXISTS, 0)
+}
+
+KeywordContext.prototype.LOAD = function() {
+  return this.getToken(CypherParser.LOAD, 0)
+}
+
+KeywordContext.prototype.CSV = function() {
+  return this.getToken(CypherParser.CSV, 0)
+}
+
+KeywordContext.prototype.WITH = function() {
+  return this.getToken(CypherParser.WITH, 0)
+}
+
+KeywordContext.prototype.HEADERS = function() {
+  return this.getToken(CypherParser.HEADERS, 0)
+}
+
+KeywordContext.prototype.FROM = function() {
+  return this.getToken(CypherParser.FROM, 0)
+}
+
+KeywordContext.prototype.AS = function() {
+  return this.getToken(CypherParser.AS, 0)
+}
+
+KeywordContext.prototype.FIELDTERMINATOR = function() {
+  return this.getToken(CypherParser.FIELDTERMINATOR, 0)
+}
+
+KeywordContext.prototype.OPTIONAL = function() {
+  return this.getToken(CypherParser.OPTIONAL, 0)
+}
+
+KeywordContext.prototype.MATCH = function() {
+  return this.getToken(CypherParser.MATCH, 0)
+}
+
+KeywordContext.prototype.UNWIND = function() {
+  return this.getToken(CypherParser.UNWIND, 0)
+}
+
+KeywordContext.prototype.MERGE = function() {
+  return this.getToken(CypherParser.MERGE, 0)
+}
+
+KeywordContext.prototype.SET = function() {
+  return this.getToken(CypherParser.SET, 0)
+}
+
+KeywordContext.prototype.DETACH = function() {
+  return this.getToken(CypherParser.DETACH, 0)
+}
+
+KeywordContext.prototype.DELETE = function() {
+  return this.getToken(CypherParser.DELETE, 0)
+}
+
+KeywordContext.prototype.REMOVE = function() {
+  return this.getToken(CypherParser.REMOVE, 0)
+}
+
+KeywordContext.prototype.FOREACH = function() {
+  return this.getToken(CypherParser.FOREACH, 0)
+}
+
+KeywordContext.prototype.IN = function() {
+  return this.getToken(CypherParser.IN, 0)
+}
+
+KeywordContext.prototype.DISTINCT = function() {
+  return this.getToken(CypherParser.DISTINCT, 0)
+}
+
+KeywordContext.prototype.RETURN = function() {
+  return this.getToken(CypherParser.RETURN, 0)
+}
+
+KeywordContext.prototype.ORDER = function() {
+  return this.getToken(CypherParser.ORDER, 0)
+}
+
+KeywordContext.prototype.BY = function() {
+  return this.getToken(CypherParser.BY, 0)
+}
+
+KeywordContext.prototype.L_SKIP = function() {
+  return this.getToken(CypherParser.L_SKIP, 0)
+}
+
+KeywordContext.prototype.LIMIT = function() {
+  return this.getToken(CypherParser.LIMIT, 0)
+}
+
+KeywordContext.prototype.ASCENDING = function() {
+  return this.getToken(CypherParser.ASCENDING, 0)
+}
+
+KeywordContext.prototype.ASC = function() {
+  return this.getToken(CypherParser.ASC, 0)
+}
+
+KeywordContext.prototype.DESCENDING = function() {
+  return this.getToken(CypherParser.DESCENDING, 0)
+}
+
+KeywordContext.prototype.DESC = function() {
+  return this.getToken(CypherParser.DESC, 0)
+}
+
+KeywordContext.prototype.JOIN = function() {
+  return this.getToken(CypherParser.JOIN, 0)
+}
+
+KeywordContext.prototype.SCAN = function() {
+  return this.getToken(CypherParser.SCAN, 0)
+}
+
+KeywordContext.prototype.START = function() {
+  return this.getToken(CypherParser.START, 0)
+}
+
+KeywordContext.prototype.NODE = function() {
+  return this.getToken(CypherParser.NODE, 0)
+}
+
+KeywordContext.prototype.RELATIONSHIP = function() {
+  return this.getToken(CypherParser.RELATIONSHIP, 0)
+}
+
+KeywordContext.prototype.REL = function() {
+  return this.getToken(CypherParser.REL, 0)
+}
+
+KeywordContext.prototype.WHERE = function() {
+  return this.getToken(CypherParser.WHERE, 0)
+}
+
+KeywordContext.prototype.SHORTESTPATH = function() {
+  return this.getToken(CypherParser.SHORTESTPATH, 0)
+}
+
+KeywordContext.prototype.ALLSHORTESTPATHS = function() {
+  return this.getToken(CypherParser.ALLSHORTESTPATHS, 0)
+}
+
+KeywordContext.prototype.OR = function() {
+  return this.getToken(CypherParser.OR, 0)
+}
+
+KeywordContext.prototype.XOR = function() {
+  return this.getToken(CypherParser.XOR, 0)
+}
+
+KeywordContext.prototype.AND = function() {
+  return this.getToken(CypherParser.AND, 0)
+}
+
+KeywordContext.prototype.NOT = function() {
+  return this.getToken(CypherParser.NOT, 0)
+}
+
+KeywordContext.prototype.STARTS = function() {
+  return this.getToken(CypherParser.STARTS, 0)
+}
+
+KeywordContext.prototype.ENDS = function() {
+  return this.getToken(CypherParser.ENDS, 0)
+}
+
+KeywordContext.prototype.CONTAINS = function() {
+  return this.getToken(CypherParser.CONTAINS, 0)
+}
+
+KeywordContext.prototype.NULL = function() {
+  return this.getToken(CypherParser.NULL, 0)
+}
+
+KeywordContext.prototype.COUNT = function() {
+  return this.getToken(CypherParser.COUNT, 0)
+}
+
+KeywordContext.prototype.FILTER = function() {
+  return this.getToken(CypherParser.FILTER, 0)
+}
+
+KeywordContext.prototype.EXTRACT = function() {
+  return this.getToken(CypherParser.EXTRACT, 0)
+}
+
+KeywordContext.prototype.ANY = function() {
+  return this.getToken(CypherParser.ANY, 0)
+}
+
+KeywordContext.prototype.NONE = function() {
+  return this.getToken(CypherParser.NONE, 0)
+}
+
+KeywordContext.prototype.SINGLE = function() {
+  return this.getToken(CypherParser.SINGLE, 0)
+}
+
+KeywordContext.prototype.TRUE = function() {
+  return this.getToken(CypherParser.TRUE, 0)
+}
+
+KeywordContext.prototype.FALSE = function() {
+  return this.getToken(CypherParser.FALSE, 0)
+}
+
+KeywordContext.prototype.REDUCE = function() {
+  return this.getToken(CypherParser.REDUCE, 0)
+}
+
+KeywordContext.prototype.CASE = function() {
+  return this.getToken(CypherParser.CASE, 0)
+}
+
+KeywordContext.prototype.ELSE = function() {
+  return this.getToken(CypherParser.ELSE, 0)
+}
+
+KeywordContext.prototype.END = function() {
+  return this.getToken(CypherParser.END, 0)
+}
+
+KeywordContext.prototype.WHEN = function() {
+  return this.getToken(CypherParser.WHEN, 0)
+}
+
+KeywordContext.prototype.THEN = function() {
+  return this.getToken(CypherParser.THEN, 0)
+}
+
+KeywordContext.prototype.CALL = function() {
+  return this.getToken(CypherParser.CALL, 0)
+}
+
+KeywordContext.prototype.YIELD = function() {
+  return this.getToken(CypherParser.YIELD, 0)
+}
+
+KeywordContext.prototype.KEY = function() {
+  return this.getToken(CypherParser.KEY, 0)
+}
+
+KeywordContext.prototype.enterRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.enterKeyword(this)
+  }
+}
+
+KeywordContext.prototype.exitRule = function(listener) {
+  if (listener instanceof CypherListener) {
+    listener.exitKeyword(this)
+  }
+}
+
+CypherParser.KeywordContext = KeywordContext
+
+CypherParser.prototype.keyword = function() {
+  var localctx = new KeywordContext(this, this._ctx, this.state)
+  this.enterRule(localctx, 404, CypherParser.RULE_keyword)
+  var _la = 0 // Token type
+  try {
+    this.enterOuterAlt(localctx, 1)
+    this.state = 2678
+    _la = this._input.LA(1)
+    if (
+      !(
+        (((_la - 54) & ~0x1f) == 0 &&
+          ((1 << (_la - 54)) &
+            ((1 << (CypherParser.CYPHER - 54)) |
+              (1 << (CypherParser.EXPLAIN - 54)) |
+              (1 << (CypherParser.PROFILE - 54)) |
+              (1 << (CypherParser.USING - 54)) |
+              (1 << (CypherParser.PERIODIC - 54)) |
+              (1 << (CypherParser.COMMIT - 54)) |
+              (1 << (CypherParser.UNION - 54)) |
+              (1 << (CypherParser.ALL - 54)) |
+              (1 << (CypherParser.CREATE - 54)) |
+              (1 << (CypherParser.DROP - 54)) |
+              (1 << (CypherParser.INDEX - 54)) |
+              (1 << (CypherParser.ON - 54)) |
+              (1 << (CypherParser.CONSTRAINT - 54)) |
+              (1 << (CypherParser.ASSERT - 54)) |
+              (1 << (CypherParser.IS - 54)) |
+              (1 << (CypherParser.UNIQUE - 54)) |
+              (1 << (CypherParser.EXISTS - 54)) |
+              (1 << (CypherParser.LOAD - 54)) |
+              (1 << (CypherParser.CSV - 54)) |
+              (1 << (CypherParser.WITH - 54)) |
+              (1 << (CypherParser.HEADERS - 54)) |
+              (1 << (CypherParser.FROM - 54)) |
+              (1 << (CypherParser.AS - 54)) |
+              (1 << (CypherParser.FIELDTERMINATOR - 54)) |
+              (1 << (CypherParser.OPTIONAL - 54)) |
+              (1 << (CypherParser.MATCH - 54)) |
+              (1 << (CypherParser.UNWIND - 54)) |
+              (1 << (CypherParser.MERGE - 54)) |
+              (1 << (CypherParser.SET - 54)) |
+              (1 << (CypherParser.DETACH - 54)) |
+              (1 << (CypherParser.DELETE - 54)) |
+              (1 << (CypherParser.REMOVE - 54)))) !==
+            0) ||
+        (((_la - 86) & ~0x1f) == 0 &&
+          ((1 << (_la - 86)) &
+            ((1 << (CypherParser.FOREACH - 86)) |
+              (1 << (CypherParser.IN - 86)) |
+              (1 << (CypherParser.DISTINCT - 86)) |
+              (1 << (CypherParser.RETURN - 86)) |
+              (1 << (CypherParser.ORDER - 86)) |
+              (1 << (CypherParser.BY - 86)) |
+              (1 << (CypherParser.L_SKIP - 86)) |
+              (1 << (CypherParser.LIMIT - 86)) |
+              (1 << (CypherParser.ASCENDING - 86)) |
+              (1 << (CypherParser.ASC - 86)) |
+              (1 << (CypherParser.DESCENDING - 86)) |
+              (1 << (CypherParser.DESC - 86)) |
+              (1 << (CypherParser.JOIN - 86)) |
+              (1 << (CypherParser.SCAN - 86)) |
+              (1 << (CypherParser.START - 86)) |
+              (1 << (CypherParser.NODE - 86)) |
+              (1 << (CypherParser.RELATIONSHIP - 86)) |
+              (1 << (CypherParser.REL - 86)) |
+              (1 << (CypherParser.WHERE - 86)) |
+              (1 << (CypherParser.SHORTESTPATH - 86)) |
+              (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
+              (1 << (CypherParser.OR - 86)) |
+              (1 << (CypherParser.XOR - 86)) |
+              (1 << (CypherParser.AND - 86)) |
+              (1 << (CypherParser.NOT - 86)) |
+              (1 << (CypherParser.STARTS - 86)) |
+              (1 << (CypherParser.ENDS - 86)) |
+              (1 << (CypherParser.CONTAINS - 86)) |
+              (1 << (CypherParser.NULL - 86)) |
+              (1 << (CypherParser.COUNT - 86)) |
+              (1 << (CypherParser.FILTER - 86)) |
+              (1 << (CypherParser.EXTRACT - 86)))) !==
+            0) ||
+        (((_la - 118) & ~0x1f) == 0 &&
+          ((1 << (_la - 118)) &
+            ((1 << (CypherParser.ANY - 118)) |
+              (1 << (CypherParser.NONE - 118)) |
+              (1 << (CypherParser.SINGLE - 118)) |
+              (1 << (CypherParser.TRUE - 118)) |
+              (1 << (CypherParser.FALSE - 118)) |
+              (1 << (CypherParser.REDUCE - 118)) |
+              (1 << (CypherParser.CASE - 118)) |
+              (1 << (CypherParser.ELSE - 118)) |
+              (1 << (CypherParser.END - 118)) |
+              (1 << (CypherParser.WHEN - 118)) |
+              (1 << (CypherParser.THEN - 118)) |
+              (1 << (CypherParser.CALL - 118)) |
+              (1 << (CypherParser.YIELD - 118)) |
+              (1 << (CypherParser.KEY - 118)))) !==
+            0)
+      )
+    ) {
+      this._errHandler.recoverInline(this)
+    } else {
+      this._errHandler.reportMatch(this)
+      this.consume()
+    }
+  } catch (re) {
+    if (re instanceof antlr4.error.RecognitionException) {
+      localctx.exception = re
+      this._errHandler.reportError(this, re)
+      this._errHandler.recover(this, re)
+    } else {
+      throw re
+    }
+  } finally {
+    this.exitRule()
+  }
+  return localctx
+}
+
+exports.CypherParser = CypherParser
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts b/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
new file mode 100644
index 00000000000..ed3d4cbee37
--- /dev/null
+++ b/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
@@ -0,0 +1,94 @@
+import * as monaco from 'monaco-editor'
+import { createLexer } from './ParserFacade'
+import ILineTokens = monaco.languages.ILineTokens
+import IToken = monaco.languages.IToken
+
+export class CypherState implements monaco.languages.IState {
+  clone(): monaco.languages.IState {
+    return new CypherState()
+  }
+
+  equals(): boolean {
+    return true
+  }
+}
+
+export class CypherTokensProvider implements monaco.languages.TokensProvider {
+  getInitialState(): monaco.languages.IState {
+    return new CypherState()
+  }
+
+  tokenize(line: string): monaco.languages.ILineTokens {
+    // So far we ignore the state, which is not great for performance reasons
+    return tokensForLine(line)
+  }
+}
+
+const EOF = -1
+
+class CypherToken implements IToken {
+  scopes: string
+  startIndex: number
+
+  constructor(ruleName: string, startIndex: number) {
+    if (ruleName === null) {
+      ruleName = ''
+    }
+    this.scopes = ruleName.toLowerCase() + '.cypher'
+    this.startIndex = startIndex
+  }
+}
+
+class CypherLineTokens implements ILineTokens {
+  endState: monaco.languages.IState
+  tokens: monaco.languages.IToken[]
+
+  constructor(tokens: monaco.languages.IToken[]) {
+    this.endState = new CypherState()
+    this.tokens = tokens
+  }
+}
+
+export function tokensForLine(input: string): monaco.languages.ILineTokens {
+  const errorStartingPoints: number[] = []
+
+  // class ErrorCollectorListener extends error.ErrorListener {
+  //     syntaxError(_recognizer, _offendingSymbol, _line, column, _msg, _e) {
+  //         errorStartingPoints.push(column)
+  //     }
+  // }
+
+  const lexer = createLexer(input)
+  lexer.removeErrorListeners()
+  // let errorListener = new ErrorCollectorListener();
+  // lexer.addErrorListener(errorListener);
+  let done = false
+  const myTokens: monaco.languages.IToken[] = []
+  do {
+    const token = lexer.nextToken()
+    if (token == null) {
+      done = true
+    } else {
+      // We exclude EOF
+      if (token.type == EOF) {
+        done = true
+      } else {
+        let tokenTypeName = lexer.symbolicNames[token.type]
+        if (tokenTypeName === null) {
+          tokenTypeName = lexer.literalNames[token.type]
+        }
+        const myToken = new CypherToken(tokenTypeName, token.column)
+        myTokens.push(myToken)
+      }
+    }
+  } while (!done)
+
+  // Add all errors
+  for (const e of errorStartingPoints) {
+    myTokens.push(new CypherToken('error.cypher', e))
+  }
+  myTokens.sort((a, b) => (a.startIndex > b.startIndex ? 1 : -1))
+  console.log(myTokens)
+
+  return new CypherLineTokens(myTokens)
+}
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts b/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
new file mode 100644
index 00000000000..0adab165dba
--- /dev/null
+++ b/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
@@ -0,0 +1,148 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import {
+  CommonTokenStream,
+  InputStream,
+  Token,
+  // error,
+  // Parser,
+  Lexer
+} from 'antlr4/index.js'
+// import { DefaultErrorStrategy } from 'antlr4/error/ErrorStrategy.js'
+import { CypherLexer } from './CypherLexer'
+import { CypherParser } from './CypherParser'
+
+// class ConsoleErrorListener extends error.ErrorListener {
+//   syntaxError(_recognizer: any, _offendingSymbol: any, _line: any, _column: any, msg: string) {
+//     console.log('ERROR ' + msg)
+//   }
+// }
+
+export class Error {
+  startLine: number
+  endLine: number
+  startCol: number
+  endCol: number
+  message: string
+
+  constructor(
+    startLine: number,
+    endLine: number,
+    startCol: number,
+    endCol: number,
+    message: string
+  ) {
+    this.startLine = startLine
+    this.endLine = endLine
+    this.startCol = startCol
+    this.endCol = endCol
+    this.message = message
+  }
+}
+
+// class CollectorErrorListener extends error.ErrorListener {
+//   private errors: Error[] = []
+
+//   constructor(errors: Error[]) {
+//     super()
+//     this.errors = errors
+//   }
+
+//   syntaxError(_recognizer: any, offendingSymbol: { _text: string | any[] | null }, line: number, column: number, msg: string) {
+//     let endColumn = column + 1
+//     if (offendingSymbol._text !== null) {
+//       endColumn = column + offendingSymbol._text.length
+//     }
+//     this.errors.push(new Error(line, line, column, endColumn, msg))
+//   }
+// }
+
+export function createLexer(input: string) {
+  const chars = new InputStream(input)
+  const lexer = new CypherLexer(chars) as any
+
+  lexer.strictMode = false
+
+  return lexer
+}
+
+export function getTokens(input: string): Token[] {
+  return createLexer(input).getAllTokens()
+}
+
+// function createParser(input: string) {
+//   const lexer = createLexer(input)
+
+//   return createParserFromLexer(lexer)
+// }
+
+function createParserFromLexer(lexer: Lexer) {
+  const tokens = new CommonTokenStream(lexer)
+  return new CypherParser(tokens)
+}
+
+// function parseTree(input: any) {
+//   const parser = createParser(input)
+
+//   return parser.compilationUnit()
+// }
+
+export function parseTreeStr(input: string) {
+  const lexer = createLexer(input)
+  lexer.removeErrorListeners()
+  // lexer.addErrorListener(new ConsoleErrorListener())
+
+  const parser = createParserFromLexer(lexer) as any
+  parser.removeErrorListeners()
+  // parser.addErrorListener(new ConsoleErrorListener())
+
+  const tree = parser.compilationUnit()
+
+  return tree.tostringTree(parser.ruleNames)
+}
+
+// class CypherErrorStrategy extends DefaultErrorStrategy {
+//   reportUnwantedToken(recognizer: Parser) {
+//     return super.reportUnwantedToken(recognizer)
+//   }
+
+//   singleTokenDeletion(recognizer: Parser) {
+//     const nextTokenType = recognizer.getTokenStream().LA(2)
+//     if (recognizer.getTokenStream().LA(1) == CypherParser.NL) {
+//       return null
+//     }
+//     const expecting = this.getExpectedTokens(recognizer)
+//     if (expecting.contains(nextTokenType)) {
+//       this.reportUnwantedToken(recognizer)
+//       recognizer.consume() // simply delete extra token
+//       // we want to return the token we're actually matching
+//       const matchedSymbol = recognizer.getCurrentToken()
+//       this.reportMatch(recognizer) // we know current token is correct
+//       return matchedSymbol
+//     } else {
+//       return null
+//     }
+//   }
+//   getExpectedTokens = function(recognizer: { getExpectedTokens: () => any }) {
+//     return recognizer.getExpectedTokens()
+//   }
+
+//   reportMatch = function(recognizer: any) {
+//     this.endErrorCondition(recognizer)
+//   }
+// }
+
+export function validate(input: string): Error[] {
+  const errors: Error[] = []
+
+  const lexer = createLexer(input)
+  lexer.removeErrorListeners()
+  // lexer.addErrorListener(new ConsoleErrorListener())
+
+  const parser = createParserFromLexer(lexer) as any
+  parser.removeErrorListeners()
+  // parser.addErrorListener(new CollectorErrorListener(errors))
+  // parser._errHandler = new CypherErrorStrategy()
+
+  parser.compilationUnit()
+  return errors
+}
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index 8cb588e6900..a2040c470a8 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -18,6 +18,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+// import * as antlr4 from 'antlr4'
 import React, { Dispatch, useEffect, useState } from 'react'
 import { connect } from 'react-redux'
 import { Action } from 'redux'
@@ -68,8 +69,8 @@ const EditFrame = (props: EditFrameProps): JSX.Element => {
   useEffect(() => {
     const themeMap: { [key in BrowserTheme]: VSTheme } = {
       [LIGHT_THEME]: VS_LIGHT_THEME,
-      [OUTLINE_THEME]: VS_DARK_THEME,
-      [DARK_THEME]: VS_HIGH_CONTRAST_THEME
+      [OUTLINE_THEME]: VS_HIGH_CONTRAST_THEME,
+      [DARK_THEME]: VS_DARK_THEME
     }
     setTheme(themeMap[derivedTheme])
   }, [derivedTheme])
diff --git a/yarn.lock b/yarn.lock
index 8f864343388..4c45333ee04 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1946,6 +1946,11 @@
     "@testing-library/dom" "^6.15.0"
     "@types/testing-library__react" "^9.1.2"
 
+"@types/antlr4@^4.7.2":
+  version "4.7.2"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/antlr4/-/antlr4-4.7.2.tgz#8cfbbcea13d45c42e9a326aa0e55df816cdd07f5"
+  integrity sha1-jPu86hPUXELpoyaqDlXfgWzdB/U=
+
 "@types/anymatch@*":
   version "1.3.1"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/anymatch/-/anymatch-1.3.1.tgz#336badc1beecb9dacc38bea2cf32adf627a8421a"
@@ -2813,6 +2818,11 @@ antlr4@4.7.0:
   resolved "https://neo.jfrog.io/neo/api/npm/npm/antlr4/-/antlr4-4.7.0.tgz#297f956ddc06f83397fc0990ecf2e0cf20bfbbee"
   integrity sha1-KX+VbdwG+DOX/AmQ7PLgzyC/u+4=
 
+antlr4@^4.8.0:
+  version "4.8.0"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/antlr4/-/antlr4-4.8.0.tgz#f938ec171be7fc2855cd3a533e87647185b32b6a"
+  integrity sha1-+TjsFxvn/ChVzTpTPodkcYWzK2o=
+
 any-observable@^0.3.0:
   version "0.3.0"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/any-observable/-/any-observable-0.3.0.tgz#af933475e5806a67d0d7df090dd5e8bef65d119b"

From 867583e032c26784c6266c70984c92ec213afb22 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Mon, 28 Sep 2020 19:48:38 +0200
Subject: [PATCH 12/23] import generated cypher lexer and parser from
 cypher-editor-support

---
 package.json                                  |     1 +
 src/browser/custom.d.ts                       |    20 +
 .../Editor/antlr-cypher-parser/CypherLexer.js |  1670 --
 .../antlr-cypher-parser/CypherListener.js     |  1268 -
 .../antlr-cypher-parser/CypherParser.js       | 24555 ----------------
 .../CypherTokensProvider.ts                   |     1 -
 .../antlr-cypher-parser/ParserFacade.ts       |    35 +-
 yarn.lock                                     |     2 +-
 8 files changed, 39 insertions(+), 27513 deletions(-)
 delete mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js
 delete mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js
 delete mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js

diff --git a/package.json b/package.json
index 77334ccafb5..509bbfa044c 100644
--- a/package.json
+++ b/package.json
@@ -159,6 +159,7 @@
     "codemirror": "^5.29.0",
     "core-js": "3",
     "cypher-codemirror": "1.1.6",
+    "cypher-editor-support": "^1.1.6",
     "d3": "3",
     "dateformat": "^3.0.3",
     "deepmerge": "^2.1.1",
diff --git a/src/browser/custom.d.ts b/src/browser/custom.d.ts
index 36a7a045be2..acc30e339ef 100644
--- a/src/browser/custom.d.ts
+++ b/src/browser/custom.d.ts
@@ -38,3 +38,23 @@ declare module 'suber' {
   const createBus: () => Bus
   export { Bus, createBus }
 }
+
+declare module 'cypher-editor-support' {
+  class CypherLexer extends (await import('antlr4/index.js')).Lexer {
+    constructor(input: unknown)
+    channelNames: string[]
+    modeNames: string[]
+    literalNames: string[]
+    symbolicNames: string[]
+    ruleNames: string[]
+    grammarFileName: string;
+    [key: string]: number
+  }
+
+  class CypherParser extends (await import('antlr4/index.js')).Parser {
+    constructor(input: unknown)
+    ruleNames: string[]
+  }
+
+  export { CypherLexer, CypherParser }
+}
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js b/src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js
deleted file mode 100644
index 36296c2a512..00000000000
--- a/src/browser/modules/Editor/antlr-cypher-parser/CypherLexer.js
+++ /dev/null
@@ -1,1670 +0,0 @@
-// Generated from cypher-editor-support/src/_generated/Cypher.g4 by ANTLR 4.7
-// jshint ignore: start
-var antlr4 = require('antlr4')
-
-var serializedATN = [
-  '\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964',
-  '\u0002\u009c\u050f\b\u0001\u0004\u0002\t\u0002\u0004\u0003\t\u0003\u0004',
-  '\u0004\t\u0004\u0004\u0005\t\u0005\u0004\u0006\t\u0006\u0004\u0007\t',
-  '\u0007\u0004\b\t\b\u0004\t\t\t\u0004\n\t\n\u0004\u000b\t\u000b\u0004',
-  '\f\t\f\u0004\r\t\r\u0004\u000e\t\u000e\u0004\u000f\t\u000f\u0004\u0010',
-  '\t\u0010\u0004\u0011\t\u0011\u0004\u0012\t\u0012\u0004\u0013\t\u0013',
-  '\u0004\u0014\t\u0014\u0004\u0015\t\u0015\u0004\u0016\t\u0016\u0004\u0017',
-  '\t\u0017\u0004\u0018\t\u0018\u0004\u0019\t\u0019\u0004\u001a\t\u001a',
-  '\u0004\u001b\t\u001b\u0004\u001c\t\u001c\u0004\u001d\t\u001d\u0004\u001e',
-  '\t\u001e\u0004\u001f\t\u001f\u0004 \t \u0004!\t!\u0004"\t"\u0004#',
-  "\t#\u0004$\t$\u0004%\t%\u0004&\t&\u0004'\t'\u0004(\t(\u0004)\t)\u0004",
-  '*\t*\u0004+\t+\u0004,\t,\u0004-\t-\u0004.\t.\u0004/\t/\u00040\t0\u0004',
-  '1\t1\u00042\t2\u00043\t3\u00044\t4\u00045\t5\u00046\t6\u00047\t7\u0004',
-  '8\t8\u00049\t9\u0004:\t:\u0004;\t;\u0004<\t<\u0004=\t=\u0004>\t>\u0004',
-  '?\t?\u0004@\t@\u0004A\tA\u0004B\tB\u0004C\tC\u0004D\tD\u0004E\tE\u0004',
-  'F\tF\u0004G\tG\u0004H\tH\u0004I\tI\u0004J\tJ\u0004K\tK\u0004L\tL\u0004',
-  'M\tM\u0004N\tN\u0004O\tO\u0004P\tP\u0004Q\tQ\u0004R\tR\u0004S\tS\u0004',
-  'T\tT\u0004U\tU\u0004V\tV\u0004W\tW\u0004X\tX\u0004Y\tY\u0004Z\tZ\u0004',
-  '[\t[\u0004\\\t\\\u0004]\t]\u0004^\t^\u0004_\t_\u0004`\t`\u0004a\ta\u0004',
-  'b\tb\u0004c\tc\u0004d\td\u0004e\te\u0004f\tf\u0004g\tg\u0004h\th\u0004',
-  'i\ti\u0004j\tj\u0004k\tk\u0004l\tl\u0004m\tm\u0004n\tn\u0004o\to\u0004',
-  'p\tp\u0004q\tq\u0004r\tr\u0004s\ts\u0004t\tt\u0004u\tu\u0004v\tv\u0004',
-  'w\tw\u0004x\tx\u0004y\ty\u0004z\tz\u0004{\t{\u0004|\t|\u0004}\t}\u0004',
-  '~\t~\u0004\u007f\t\u007f\u0004\u0080\t\u0080\u0004\u0081\t\u0081\u0004',
-  '\u0082\t\u0082\u0004\u0083\t\u0083\u0004\u0084\t\u0084\u0004\u0085\t',
-  '\u0085\u0004\u0086\t\u0086\u0004\u0087\t\u0087\u0004\u0088\t\u0088\u0004',
-  '\u0089\t\u0089\u0004\u008a\t\u008a\u0004\u008b\t\u008b\u0004\u008c\t',
-  '\u008c\u0004\u008d\t\u008d\u0004\u008e\t\u008e\u0004\u008f\t\u008f\u0004',
-  '\u0090\t\u0090\u0004\u0091\t\u0091\u0004\u0092\t\u0092\u0004\u0093\t',
-  '\u0093\u0004\u0094\t\u0094\u0004\u0095\t\u0095\u0004\u0096\t\u0096\u0004',
-  '\u0097\t\u0097\u0004\u0098\t\u0098\u0004\u0099\t\u0099\u0004\u009a\t',
-  '\u009a\u0004\u009b\t\u009b\u0004\u009c\t\u009c\u0004\u009d\t\u009d\u0004',
-  '\u009e\t\u009e\u0004\u009f\t\u009f\u0004\u00a0\t\u00a0\u0004\u00a1\t',
-  '\u00a1\u0004\u00a2\t\u00a2\u0004\u00a3\t\u00a3\u0004\u00a4\t\u00a4\u0004',
-  '\u00a5\t\u00a5\u0004\u00a6\t\u00a6\u0004\u00a7\t\u00a7\u0004\u00a8\t',
-  '\u00a8\u0004\u00a9\t\u00a9\u0004\u00aa\t\u00aa\u0004\u00ab\t\u00ab\u0004',
-  '\u00ac\t\u00ac\u0004\u00ad\t\u00ad\u0004\u00ae\t\u00ae\u0004\u00af\t',
-  '\u00af\u0004\u00b0\t\u00b0\u0004\u00b1\t\u00b1\u0004\u00b2\t\u00b2\u0004',
-  '\u00b3\t\u00b3\u0004\u00b4\t\u00b4\u0004\u00b5\t\u00b5\u0004\u00b6\t',
-  '\u00b6\u0004\u00b7\t\u00b7\u0004\u00b8\t\u00b8\u0004\u00b9\t\u00b9\u0004',
-  '\u00ba\t\u00ba\u0004\u00bb\t\u00bb\u0004\u00bc\t\u00bc\u0004\u00bd\t',
-  '\u00bd\u0004\u00be\t\u00be\u0004\u00bf\t\u00bf\u0004\u00c0\t\u00c0\u0004',
-  '\u00c1\t\u00c1\u0004\u00c2\t\u00c2\u0003\u0002\u0003\u0002\u0003\u0003',
-  '\u0003\u0003\u0003\u0004\u0003\u0004\u0003\u0005\u0003\u0005\u0003\u0005',
-  '\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0007\u0003\u0007',
-  '\u0003\b\u0003\b\u0003\t\u0003\t\u0003\n\u0003\n\u0003\u000b\u0003\u000b',
-  '\u0003\f\u0003\f\u0003\r\u0003\r\u0003\u000e\u0003\u000e\u0003\u000f',
-  '\u0003\u000f\u0003\u0010\u0003\u0010\u0003\u0011\u0003\u0011\u0003\u0012',
-  '\u0003\u0012\u0003\u0013\u0003\u0013\u0003\u0014\u0003\u0014\u0003\u0015',
-  '\u0003\u0015\u0003\u0016\u0003\u0016\u0003\u0016\u0003\u0017\u0003\u0017',
-  '\u0003\u0018\u0003\u0018\u0003\u0019\u0003\u0019\u0003\u0019\u0003\u001a',
-  '\u0003\u001a\u0003\u001b\u0003\u001b\u0003\u001c\u0003\u001c\u0003\u001c',
-  '\u0003\u001d\u0003\u001d\u0003\u001d\u0003\u001e\u0003\u001e\u0003\u001e',
-  '\u0003\u001f\u0003\u001f\u0003 \u0003 \u0003!\u0003!\u0003!\u0003"',
-  '\u0003"\u0003"\u0003#\u0003#\u0003$\u0003$\u0003%\u0003%\u0003&\u0003',
-  "&\u0003'\u0003'\u0003(\u0003(\u0003)\u0003)\u0003*\u0003*\u0003+\u0003",
-  '+\u0003,\u0003,\u0003-\u0003-\u0003.\u0003.\u0003/\u0003/\u00030\u0003',
-  '0\u00031\u00031\u00032\u00032\u00033\u00033\u00034\u00034\u00035\u0003',
-  '5\u00036\u00036\u00037\u00037\u00037\u00037\u00037\u00037\u00037\u0003',
-  '8\u00038\u00038\u00038\u00038\u00038\u00038\u00038\u00039\u00039\u0003',
-  '9\u00039\u00039\u00039\u00039\u00039\u0003:\u0003:\u0003:\u0003:\u0003',
-  ':\u0003:\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003',
-  ';\u0003<\u0003<\u0003<\u0003<\u0003<\u0003<\u0003<\u0003=\u0003=\u0003',
-  '=\u0003=\u0003=\u0003=\u0003>\u0003>\u0003>\u0003>\u0003?\u0003?\u0003',
-  '?\u0003?\u0003?\u0003?\u0003?\u0003@\u0003@\u0003@\u0003@\u0003@\u0003',
-  'A\u0003A\u0003A\u0003A\u0003A\u0003A\u0003B\u0003B\u0003B\u0003C\u0003',
-  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003',
-  'D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003E\u0003E\u0003E\u0003',
-  'F\u0003F\u0003F\u0003F\u0003F\u0003F\u0003F\u0003G\u0003G\u0003G\u0003',
-  'G\u0003G\u0003G\u0003G\u0003H\u0003H\u0003H\u0003H\u0003H\u0003I\u0003',
-  'I\u0003I\u0003I\u0003J\u0003J\u0003J\u0003J\u0003J\u0003K\u0003K\u0003',
-  'K\u0003K\u0003K\u0003K\u0003K\u0003K\u0003L\u0003L\u0003L\u0003L\u0003',
-  'L\u0003M\u0003M\u0003M\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003',
-  'N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003N\u0003',
-  'O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003P\u0003',
-  'P\u0003P\u0003P\u0003P\u0003P\u0003Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003',
-  'Q\u0003Q\u0003R\u0003R\u0003R\u0003R\u0003R\u0003R\u0003S\u0003S\u0003',
-  'S\u0003S\u0003T\u0003T\u0003T\u0003T\u0003T\u0003T\u0003T\u0003U\u0003',
-  'U\u0003U\u0003U\u0003U\u0003U\u0003U\u0003V\u0003V\u0003V\u0003V\u0003',
-  'V\u0003V\u0003V\u0003W\u0003W\u0003W\u0003W\u0003W\u0003W\u0003W\u0003',
-  'W\u0003X\u0003X\u0003X\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003',
-  'Y\u0003Y\u0003Y\u0003Z\u0003Z\u0003Z\u0003Z\u0003Z\u0003Z\u0003Z\u0003',
-  '[\u0003[\u0003[\u0003[\u0003[\u0003[\u0003\\\u0003\\\u0003\\\u0003]',
-  '\u0003]\u0003]\u0003]\u0003]\u0003^\u0003^\u0003^\u0003^\u0003^\u0003',
-  '^\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0003',
-  '_\u0003`\u0003`\u0003`\u0003`\u0003a\u0003a\u0003a\u0003a\u0003a\u0003',
-  'a\u0003a\u0003a\u0003a\u0003a\u0003a\u0003b\u0003b\u0003b\u0003b\u0003',
-  'b\u0003c\u0003c\u0003c\u0003c\u0003c\u0003d\u0003d\u0003d\u0003d\u0003',
-  'd\u0003e\u0003e\u0003e\u0003e\u0003e\u0003e\u0003f\u0003f\u0003f\u0003',
-  'f\u0003f\u0003g\u0003g\u0003g\u0003g\u0003g\u0003g\u0003g\u0003g\u0003',
-  'g\u0003g\u0003g\u0003g\u0003g\u0003h\u0003h\u0003h\u0003h\u0003i\u0003',
-  'i\u0003i\u0003i\u0003i\u0003i\u0003j\u0003j\u0003j\u0003j\u0003j\u0003',
-  'j\u0003j\u0003j\u0003j\u0003j\u0003j\u0003j\u0003j\u0003k\u0003k\u0003',
-  'k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003',
-  'k\u0003k\u0003k\u0003k\u0003k\u0003l\u0003l\u0003l\u0003m\u0003m\u0003',
-  'm\u0003m\u0003n\u0003n\u0003n\u0003n\u0003o\u0003o\u0003o\u0003o\u0003',
-  'p\u0003p\u0003p\u0003p\u0003p\u0003p\u0003p\u0003q\u0003q\u0003q\u0003',
-  'q\u0003q\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003',
-  'r\u0003s\u0003s\u0003s\u0003s\u0003s\u0003t\u0003t\u0003t\u0003t\u0003',
-  't\u0003t\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003v\u0003',
-  'v\u0003v\u0003v\u0003v\u0003v\u0003v\u0003v\u0003w\u0003w\u0003w\u0003',
-  'w\u0003x\u0003x\u0003x\u0003x\u0003x\u0003y\u0003y\u0003y\u0003y\u0003',
-  'y\u0003y\u0003y\u0003z\u0003z\u0003z\u0003z\u0003z\u0003{\u0003{\u0003',
-  '{\u0003{\u0003{\u0003{\u0003|\u0003|\u0003|\u0003|\u0003|\u0003|\u0003',
-  '|\u0003}\u0003}\u0003}\u0003}\u0003}\u0003~\u0003~\u0003~\u0003~\u0003',
-  '~\u0003\u007f\u0003\u007f\u0003\u007f\u0003\u007f\u0003\u0080\u0003',
-  '\u0080\u0003\u0080\u0003\u0080\u0003\u0080\u0003\u0081\u0003\u0081\u0003',
-  '\u0081\u0003\u0081\u0003\u0081\u0003\u0082\u0003\u0082\u0003\u0082\u0003',
-  '\u0082\u0003\u0082\u0003\u0083\u0003\u0083\u0003\u0083\u0003\u0083\u0003',
-  '\u0083\u0003\u0083\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003',
-  '\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0005\u0085\u03ef',
-  '\n\u0085\u0007\u0085\u03f1\n\u0085\f\u0085\u000e\u0085\u03f4\u000b\u0085',
-  '\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085',
-  '\u0005\u0085\u03fc\n\u0085\u0007\u0085\u03fe\n\u0085\f\u0085\u000e\u0085',
-  '\u0401\u000b\u0085\u0003\u0085\u0005\u0085\u0404\n\u0085\u0003\u0086',
-  '\u0003\u0086\u0003\u0086\u0006\u0086\u0409\n\u0086\r\u0086\u000e\u0086',
-  '\u040a\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003',
-  '\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003',
-  '\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003',
-  '\u0087\u0005\u0087\u041f\n\u0087\u0003\u0088\u0003\u0088\u0003\u0088',
-  '\u0003\u0088\u0006\u0088\u0425\n\u0088\r\u0088\u000e\u0088\u0426\u0003',
-  '\u0089\u0003\u0089\u0003\u0089\u0007\u0089\u042c\n\u0089\f\u0089\u000e',
-  '\u0089\u042f\u000b\u0089\u0005\u0089\u0431\n\u0089\u0003\u008a\u0003',
-  '\u008a\u0006\u008a\u0435\n\u008a\r\u008a\u000e\u008a\u0436\u0003\u008b',
-  '\u0005\u008b\u043a\n\u008b\u0003\u008c\u0003\u008c\u0005\u008c\u043e',
-  '\n\u008c\u0003\u008d\u0003\u008d\u0005\u008d\u0442\n\u008d\u0003\u008e',
-  '\u0003\u008e\u0005\u008e\u0446\n\u008e\u0003\u008f\u0003\u008f\u0003',
-  '\u0090\u0003\u0090\u0005\u0090\u044c\n\u0090\u0003\u0091\u0003\u0091',
-  '\u0003\u0092\u0006\u0092\u0451\n\u0092\r\u0092\u000e\u0092\u0452\u0003',
-  '\u0092\u0006\u0092\u0456\n\u0092\r\u0092\u000e\u0092\u0457\u0003\u0092',
-  '\u0003\u0092\u0006\u0092\u045c\n\u0092\r\u0092\u000e\u0092\u045d\u0003',
-  '\u0092\u0003\u0092\u0006\u0092\u0462\n\u0092\r\u0092\u000e\u0092\u0463',
-  '\u0005\u0092\u0466\n\u0092\u0003\u0092\u0003\u0092\u0005\u0092\u046a',
-  '\n\u0092\u0003\u0092\u0006\u0092\u046d\n\u0092\r\u0092\u000e\u0092\u046e',
-  '\u0003\u0093\u0007\u0093\u0472\n\u0093\f\u0093\u000e\u0093\u0475\u000b',
-  '\u0093\u0003\u0093\u0003\u0093\u0006\u0093\u0479\n\u0093\r\u0093\u000e',
-  '\u0093\u047a\u0003\u0094\u0003\u0094\u0007\u0094\u047f\n\u0094\f\u0094',
-  '\u000e\u0094\u0482\u000b\u0094\u0003\u0095\u0003\u0095\u0005\u0095\u0486',
-  '\n\u0095\u0003\u0096\u0003\u0096\u0005\u0096\u048a\n\u0096\u0003\u0097',
-  '\u0003\u0097\u0003\u0097\u0003\u0097\u0007\u0097\u0490\n\u0097\f\u0097',
-  '\u000e\u0097\u0493\u000b\u0097\u0003\u0097\u0003\u0097\u0003\u0098\u0006',
-  '\u0098\u0498\n\u0098\r\u0098\u000e\u0098\u0499\u0003\u0099\u0003\u0099',
-  '\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099',
-  '\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0005\u0099\u04a8\n',
-  '\u0099\u0003\u009a\u0003\u009a\u0003\u009a\u0003\u009a\u0007\u009a\u04ae',
-  '\n\u009a\f\u009a\u000e\u009a\u04b1\u000b\u009a\u0003\u009a\u0003\u009a',
-  '\u0003\u009a\u0003\u009a\u0003\u009a\u0003\u009a\u0007\u009a\u04b9\n',
-  '\u009a\f\u009a\u000e\u009a\u04bc\u000b\u009a\u0005\u009a\u04be\n\u009a',
-  '\u0003\u009b\u0003\u009b\u0003\u009c\u0003\u009c\u0003\u009d\u0003\u009d',
-  '\u0003\u009e\u0003\u009e\u0003\u009f\u0003\u009f\u0003\u00a0\u0003\u00a0',
-  '\u0003\u00a1\u0003\u00a1\u0003\u00a2\u0003\u00a2\u0003\u00a3\u0003\u00a3',
-  '\u0003\u00a4\u0003\u00a4\u0003\u00a5\u0003\u00a5\u0003\u00a6\u0003\u00a6',
-  '\u0003\u00a7\u0003\u00a7\u0003\u00a8\u0003\u00a8\u0003\u00a9\u0003\u00a9',
-  '\u0003\u00aa\u0003\u00aa\u0003\u00ab\u0003\u00ab\u0003\u00ac\u0003\u00ac',
-  '\u0003\u00ad\u0003\u00ad\u0003\u00ae\u0003\u00ae\u0003\u00af\u0003\u00af',
-  '\u0003\u00b0\u0003\u00b0\u0003\u00b1\u0003\u00b1\u0003\u00b2\u0003\u00b2',
-  '\u0003\u00b3\u0003\u00b3\u0003\u00b4\u0003\u00b4\u0003\u00b5\u0003\u00b5',
-  '\u0003\u00b6\u0003\u00b6\u0003\u00b7\u0003\u00b7\u0003\u00b8\u0003\u00b8',
-  '\u0003\u00b9\u0003\u00b9\u0003\u00ba\u0003\u00ba\u0003\u00bb\u0003\u00bb',
-  '\u0003\u00bc\u0003\u00bc\u0003\u00bd\u0003\u00bd\u0003\u00be\u0003\u00be',
-  '\u0003\u00bf\u0003\u00bf\u0003\u00c0\u0003\u00c0\u0003\u00c1\u0003\u00c1',
-  '\u0003\u00c2\u0003\u00c2\u0003\u04af\u0002\u00c3\u0003\u0003\u0005\u0004',
-  '\u0007\u0005\t\u0006\u000b\u0007\r\b\u000f\t\u0011\n\u0013\u000b\u0015',
-  '\f\u0017\r\u0019\u000e\u001b\u000f\u001d\u0010\u001f\u0011!\u0012#\u0013',
-  "%\u0014'\u0015)\u0016+\u0017-\u0018/\u00191\u001a3\u001b5\u001c7\u001d",
-  '9\u001e;\u001f= ?!A"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]0_1a2c3e4g5i6k7m8o',
-  '9q:s;u<w=y>{?}@\u007fA\u0081B\u0083C\u0085D\u0087E\u0089F\u008bG\u008d',
-  'H\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1',
-  'R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5',
-  '\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5d\u00c7e\u00c9',
-  'f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9n\u00dbo\u00dd',
-  'p\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1',
-  'z\u00f3{\u00f5|\u00f7}\u00f9~\u00fb\u007f\u00fd\u0080\u00ff\u0081\u0101',
-  '\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\u0086\u010b\u0087\u010d',
-  '\u0088\u010f\u0089\u0111\u008a\u0113\u008b\u0115\u008c\u0117\u008d\u0119',
-  '\u008e\u011b\u008f\u011d\u0090\u011f\u0091\u0121\u0092\u0123\u0093\u0125',
-  '\u0094\u0127\u0095\u0129\u0096\u012b\u0097\u012d\u0098\u012f\u0099\u0131',
-  '\u009a\u0133\u009b\u0135\u009c\u0137\u0002\u0139\u0002\u013b\u0002\u013d',
-  '\u0002\u013f\u0002\u0141\u0002\u0143\u0002\u0145\u0002\u0147\u0002\u0149',
-  '\u0002\u014b\u0002\u014d\u0002\u014f\u0002\u0151\u0002\u0153\u0002\u0155',
-  '\u0002\u0157\u0002\u0159\u0002\u015b\u0002\u015d\u0002\u015f\u0002\u0161',
-  '\u0002\u0163\u0002\u0165\u0002\u0167\u0002\u0169\u0002\u016b\u0002\u016d',
-  '\u0002\u016f\u0002\u0171\u0002\u0173\u0002\u0175\u0002\u0177\u0002\u0179',
-  '\u0002\u017b\u0002\u017d\u0002\u017f\u0002\u0181\u0002\u0183\u0002\u0003',
-  '\u00022\u0004\u0002$$^^\u0004\u0002))^^\u0005\u00022;CHch\u000f\u0002',
-  '$$))DDHHPPTTVV^^ddhhppttvv\u0004\u0002WWww\u0004\u0002CHch\u0004\u0002',
-  'GGgg\b\u0002aa\u2041\u2042\u2056\u2056\ufe35\ufe36\ufe4f\ufe51\uff41',
-  '\uff41\u0003\u0002bb\n\u0002\u00a2\u00a2\u1682\u1682\u1810\u1810\u2002',
-  '\u200c\u202a\u202b\u2031\u2031\u2061\u2061\u3002\u3002\u0004\u0002\f',
-  '\f\u000f\u000f\u0003\u0002\u000e\u000e\u0003\u0002  \u01af\u00022;C',
-  '\\aac|\u00ac\u00ac\u00b7\u00b7\u00b9\u00b9\u00bc\u00bc\u00c2\u00d8\u00da',
-  '\u00f8\u00fa\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0\u0302',
-  '\u0376\u0378\u0379\u037c\u037f\u0388\u038c\u038e\u038e\u0390\u03a3\u03a5',
-  '\u03f7\u03f9\u0483\u0485\u0489\u048c\u0529\u0533\u0558\u055b\u055b\u0563',
-  '\u0589\u0593\u05bf\u05c1\u05c1\u05c3\u05c4\u05c6\u05c7\u05c9\u05c9\u05d2',
-  '\u05ec\u05f2\u05f4\u0612\u061c\u0622\u066b\u0670\u06d5\u06d7\u06de\u06e1',
-  '\u06ea\u06ec\u06fe\u0701\u0701\u0712\u074c\u074f\u07b3\u07c2\u07f7\u07fc',
-  '\u07fc\u0802\u082f\u0842\u085d\u08a2\u08a2\u08a4\u08ae\u08e6\u0900\u0902',
-  '\u0965\u0968\u0971\u0973\u0979\u097b\u0981\u0983\u0985\u0987\u098e\u0991',
-  '\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4\u09b8\u09bb\u09be\u09c6\u09c9',
-  '\u09ca\u09cd\u09d0\u09d9\u09d9\u09de\u09df\u09e1\u09e5\u09e8\u09f3\u0a03',
-  '\u0a05\u0a07\u0a0c\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37',
-  '\u0a38\u0a3a\u0a3b\u0a3e\u0a3e\u0a40\u0a44\u0a49\u0a4a\u0a4d\u0a4f\u0a53',
-  '\u0a53\u0a5b\u0a5e\u0a60\u0a60\u0a68\u0a77\u0a83\u0a85\u0a87\u0a8f\u0a91',
-  '\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4\u0ab5\u0ab7\u0abb\u0abe\u0ac7\u0ac9',
-  '\u0acb\u0acd\u0acf\u0ad2\u0ad2\u0ae2\u0ae5\u0ae8\u0af1\u0b03\u0b05\u0b07',
-  '\u0b0e\u0b11\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3e',
-  '\u0b46\u0b49\u0b4a\u0b4d\u0b4f\u0b58\u0b59\u0b5e\u0b5f\u0b61\u0b65\u0b68',
-  '\u0b71\u0b73\u0b73\u0b84\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b',
-  '\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0\u0bbb\u0bc0',
-  '\u0bc4\u0bc8\u0bca\u0bcc\u0bcf\u0bd2\u0bd2\u0bd9\u0bd9\u0be8\u0bf1\u0c03',
-  '\u0c05\u0c07\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c3f',
-  '\u0c46\u0c48\u0c4a\u0c4c\u0c4f\u0c57\u0c58\u0c5a\u0c5b\u0c62\u0c65\u0c68',
-  '\u0c71\u0c84\u0c85\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7',
-  '\u0cbb\u0cbe\u0cc6\u0cc8\u0cca\u0ccc\u0ccf\u0cd7\u0cd8\u0ce0\u0ce0\u0ce2',
-  '\u0ce5\u0ce8\u0cf1\u0cf3\u0cf4\u0d04\u0d05\u0d07\u0d0e\u0d10\u0d12\u0d14',
-  '\u0d3c\u0d3f\u0d46\u0d48\u0d4a\u0d4c\u0d50\u0d59\u0d59\u0d62\u0d65\u0d68',
-  '\u0d71\u0d7c\u0d81\u0d84\u0d85\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf',
-  '\u0dbf\u0dc2\u0dc8\u0dcc\u0dcc\u0dd1\u0dd6\u0dd8\u0dd8\u0dda\u0de1\u0df4',
-  '\u0df5\u0e03\u0e3c\u0e42\u0e50\u0e52\u0e5b\u0e83\u0e84\u0e86\u0e86\u0e89',
-  '\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7',
-  '\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0ebb\u0ebd\u0ebf\u0ec2\u0ec6\u0ec8',
-  '\u0ec8\u0eca\u0ecf\u0ed2\u0edb\u0ede\u0ee1\u0f02\u0f02\u0f1a\u0f1b\u0f22',
-  '\u0f2b\u0f37\u0f37\u0f39\u0f39\u0f3b\u0f3b\u0f40\u0f49\u0f4b\u0f6e\u0f73',
-  '\u0f86\u0f88\u0f99\u0f9b\u0fbe\u0fc8\u0fc8\u1002\u104b\u1052\u109f\u10a2',
-  '\u10c7\u10c9\u10c9\u10cf\u10cf\u10d2\u10fc\u10fe\u124a\u124c\u124f\u1252',
-  '\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4',
-  '\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312\u1314',
-  '\u1317\u131a\u135c\u135f\u1361\u136b\u1373\u1382\u1391\u13a2\u13f6\u1403',
-  '\u166e\u1671\u1681\u1683\u169c\u16a2\u16ec\u16f0\u16f2\u1702\u170e\u1710',
-  '\u1716\u1722\u1736\u1742\u1755\u1762\u176e\u1770\u1772\u1774\u1775\u1782',
-  '\u17d5\u17d9\u17d9\u17de\u17df\u17e2\u17eb\u180d\u180f\u1812\u181b\u1822',
-  '\u1879\u1882\u18ac\u18b2\u18f7\u1902\u191e\u1922\u192d\u1932\u193d\u1948',
-  '\u196f\u1972\u1976\u1982\u19ad\u19b2\u19cb\u19d2\u19dc\u1a02\u1a1d\u1a22',
-  '\u1a60\u1a62\u1a7e\u1a81\u1a8b\u1a92\u1a9b\u1aa9\u1aa9\u1b02\u1b4d\u1b52',
-  '\u1b5b\u1b6d\u1b75\u1b82\u1bf5\u1c02\u1c39\u1c42\u1c4b\u1c4f\u1c7f\u1cd2',
-  '\u1cd4\u1cd6\u1cf8\u1d02\u1de8\u1dfe\u1f17\u1f1a\u1f1f\u1f22\u1f47\u1f4a',
-  '\u1f4f\u1f52\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f7f\u1f82',
-  '\u1fb6\u1fb8\u1fbe\u1fc0\u1fc0\u1fc4\u1fc6\u1fc8\u1fce\u1fd2\u1fd5\u1fd8',
-  '\u1fdd\u1fe2\u1fee\u1ff4\u1ff6\u1ff8\u1ffe\u2041\u2042\u2056\u2056\u2073',
-  '\u2073\u2081\u2081\u2092\u209e\u20d2\u20de\u20e3\u20e3\u20e7\u20f2\u2104',
-  '\u2104\u2109\u2109\u210c\u2115\u2117\u2117\u211a\u211f\u2126\u2126\u2128',
-  '\u2128\u212a\u212a\u212c\u213b\u213e\u2141\u2147\u214b\u2150\u2150\u2162',
-  '\u218a\u2c02\u2c30\u2c32\u2c60\u2c62\u2ce6\u2ced\u2cf5\u2d02\u2d27\u2d29',
-  '\u2d29\u2d2f\u2d2f\u2d32\u2d69\u2d71\u2d71\u2d81\u2d98\u2da2\u2da8\u2daa',
-  '\u2db0\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda',
-  '\u2de0\u2de2\u2e01\u3007\u3009\u3023\u3031\u3033\u3037\u303a\u303e\u3043',
-  '\u3098\u309b\u30a1\u30a3\u30fc\u30fe\u3101\u3107\u312f\u3133\u3190\u31a2',
-  '\u31bc\u31f2\u3201\u3402\u4db7\u4e02\u9fce\ua002\ua48e\ua4d2\ua4ff\ua502',
-  '\ua60e\ua612\ua62d\ua642\ua671\ua676\ua67f\ua681\ua699\ua6a1\ua6f3\ua719',
-  '\ua721\ua724\ua78a\ua78d\ua790\ua792\ua795\ua7a2\ua7ac\ua7fa\ua829\ua842',
-  '\ua875\ua882\ua8c6\ua8d2\ua8db\ua8e2\ua8f9\ua8fd\ua8fd\ua902\ua92f\ua932',
-  '\ua955\ua962\ua97e\ua982\ua9c2\ua9d1\ua9db\uaa02\uaa38\uaa42\uaa4f\uaa52',
-  '\uaa5b\uaa62\uaa78\uaa7c\uaa7d\uaa82\uaac4\uaadd\uaadf\uaae2\uaaf1\uaaf4',
-  '\uaaf8\uab03\uab08\uab0b\uab10\uab13\uab18\uab22\uab28\uab2a\uab30\uabc2',
-  '\uabec\uabee\uabef\uabf2\uabfb\uac02\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902',
-  '\ufa6f\ufa72\ufadb\ufb02\ufb08\ufb15\ufb19\ufb1f\ufb2a\ufb2c\ufb38\ufb3a',
-  '\ufb3e\ufb40\ufb40\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52',
-  '\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe02\ufe11\ufe22\ufe28\ufe35\ufe36\ufe4f',
-  '\ufe51\ufe72\ufe76\ufe78\ufefe\uff12\uff1b\uff23\uff3c\uff41\uff41\uff43',
-  '\uff5c\uff68\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\u0003',
-  '\u0002\u001f\u001f\u0003\u0002\u001e\u001e\u0003\u0002\u000f\u000f\u0013',
-  '\u0002&&\u00a4\u00a7\u0591\u0591\u060d\u060d\u09f4\u09f5\u09fd\u09fd',
-  '\u0af3\u0af3\u0bfb\u0bfb\u0e41\u0e41\u17dd\u17dd\u20a2\u20bc\ua83a\ua83a',
-  '\ufdfe\ufdfe\ufe6b\ufe6b\uff06\uff06\uffe2\uffe3\uffe7\uffe8\u0003\u0002',
-  '""\u0003\u0002\u000b\u000b\u0003\u0002\f\f\u0003\u0002\r\r\u0003\u0002',
-  '!!\u0174\u0002C\\c|\u00ac\u00ac\u00b7\u00b7\u00bc\u00bc\u00c2\u00d8',
-  '\u00da\u00f8\u00fa\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0',
-  '\u0372\u0376\u0378\u0379\u037c\u037f\u0388\u0388\u038a\u038c\u038e\u038e',
-  '\u0390\u03a3\u03a5\u03f7\u03f9\u0483\u048c\u0529\u0533\u0558\u055b\u055b',
-  '\u0563\u0589\u05d2\u05ec\u05f2\u05f4\u0622\u064c\u0670\u0671\u0673\u06d5',
-  '\u06d7\u06d7\u06e7\u06e8\u06f0\u06f1\u06fc\u06fe\u0701\u0701\u0712\u0712',
-  '\u0714\u0731\u074f\u07a7\u07b3\u07b3\u07cc\u07ec\u07f6\u07f7\u07fc\u07fc',
-  '\u0802\u0817\u081c\u081c\u0826\u0826\u082a\u082a\u0842\u085a\u08a2\u08a2',
-  '\u08a4\u08ae\u0906\u093b\u093f\u093f\u0952\u0952\u095a\u0963\u0973\u0979',
-  '\u097b\u0981\u0987\u098e\u0991\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4',
-  '\u09b8\u09bb\u09bf\u09bf\u09d0\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3',
-  '\u0a07\u0a0c\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38',
-  '\u0a3a\u0a3b\u0a5b\u0a5e\u0a60\u0a60\u0a74\u0a76\u0a87\u0a8f\u0a91\u0a93',
-  '\u0a95\u0aaa\u0aac\u0ab2\u0ab4\u0ab5\u0ab7\u0abb\u0abf\u0abf\u0ad2\u0ad2',
-  '\u0ae2\u0ae3\u0b07\u0b0e\u0b11\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35',
-  '\u0b37\u0b3b\u0b3f\u0b3f\u0b5e\u0b5f\u0b61\u0b63\u0b73\u0b73\u0b85\u0b85',
-  '\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1',
-  '\u0ba5\u0ba6\u0baa\u0bac\u0bb0\u0bbb\u0bd2\u0bd2\u0c07\u0c0e\u0c10\u0c12',
-  '\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c3f\u0c3f\u0c5a\u0c5b\u0c62\u0c63',
-  '\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf\u0cbf',
-  '\u0ce0\u0ce0\u0ce2\u0ce3\u0cf3\u0cf4\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d3c',
-  '\u0d3f\u0d3f\u0d50\u0d50\u0d62\u0d63\u0d7c\u0d81\u0d87\u0d98\u0d9c\u0db3',
-  '\u0db5\u0dbd\u0dbf\u0dbf\u0dc2\u0dc8\u0e03\u0e32\u0e34\u0e35\u0e42\u0e48',
-  '\u0e83\u0e84\u0e86\u0e86\u0e89\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99',
-  '\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0eb2',
-  '\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2\u0ec6\u0ec8\u0ec8\u0ede\u0ee1\u0f02\u0f02',
-  '\u0f42\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002\u102c\u1041\u1041\u1052\u1057',
-  '\u105c\u105f\u1063\u1063\u1067\u1068\u1070\u1072\u1077\u1083\u1090\u1090',
-  '\u10a2\u10c7\u10c9\u10c9\u10cf\u10cf\u10d2\u10fc\u10fe\u124a\u124c\u124f',
-  '\u1252\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292\u12b2',
-  '\u12b4\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312',
-  '\u1314\u1317\u131a\u135c\u1382\u1391\u13a2\u13f6\u1403\u166e\u1671\u1681',
-  '\u1683\u169c\u16a2\u16ec\u16f0\u16f2\u1702\u170e\u1710\u1713\u1722\u1733',
-  '\u1742\u1753\u1762\u176e\u1770\u1772\u1782\u17b5\u17d9\u17d9\u17de\u17de',
-  '\u1822\u1879\u1882\u18aa\u18ac\u18ac\u18b2\u18f7\u1902\u191e\u1952\u196f',
-  '\u1972\u1976\u1982\u19ad\u19c3\u19c9\u1a02\u1a18\u1a22\u1a56\u1aa9\u1aa9',
-  '\u1b07\u1b35\u1b47\u1b4d\u1b85\u1ba2\u1bb0\u1bb1\u1bbc\u1be7\u1c02\u1c25',
-  '\u1c4f\u1c51\u1c5c\u1c7f\u1ceb\u1cee\u1cf0\u1cf3\u1cf7\u1cf8\u1d02\u1dc1',
-  '\u1e02\u1f17\u1f1a\u1f1f\u1f22\u1f47\u1f4a\u1f4f\u1f52\u1f59\u1f5b\u1f5b',
-  '\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f7f\u1f82\u1fb6\u1fb8\u1fbe\u1fc0\u1fc0',
-  '\u1fc4\u1fc6\u1fc8\u1fce\u1fd2\u1fd5\u1fd8\u1fdd\u1fe2\u1fee\u1ff4\u1ff6',
-  '\u1ff8\u1ffe\u2073\u2073\u2081\u2081\u2092\u209e\u2104\u2104\u2109\u2109',
-  '\u210c\u2115\u2117\u2117\u211a\u211f\u2126\u2126\u2128\u2128\u212a\u212a',
-  '\u212c\u213b\u213e\u2141\u2147\u214b\u2150\u2150\u2162\u218a\u2c02\u2c30',
-  '\u2c32\u2c60\u2c62\u2ce6\u2ced\u2cf0\u2cf4\u2cf5\u2d02\u2d27\u2d29\u2d29',
-  '\u2d2f\u2d2f\u2d32\u2d69\u2d71\u2d71\u2d82\u2d98\u2da2\u2da8\u2daa\u2db0',
-  '\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda\u2de0',
-  '\u3007\u3009\u3023\u302b\u3033\u3037\u303a\u303e\u3043\u3098\u309d\u30a1',
-  '\u30a3\u30fc\u30fe\u3101\u3107\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201',
-  '\u3402\u4db7\u4e02\u9fce\ua002\ua48e\ua4d2\ua4ff\ua502\ua60e\ua612\ua621',
-  '\ua62c\ua62d\ua642\ua670\ua681\ua699\ua6a2\ua6f1\ua719\ua721\ua724\ua78a',
-  '\ua78d\ua790\ua792\ua795\ua7a2\ua7ac\ua7fa\ua803\ua805\ua807\ua809\ua80c',
-  '\ua80e\ua824\ua842\ua875\ua884\ua8b5\ua8f4\ua8f9\ua8fd\ua8fd\ua90c\ua927',
-  '\ua932\ua948\ua962\ua97e\ua986\ua9b4\ua9d1\ua9d1\uaa02\uaa2a\uaa42\uaa44',
-  '\uaa46\uaa4d\uaa62\uaa78\uaa7c\uaa7c\uaa82\uaab1\uaab3\uaab3\uaab7\uaab8',
-  '\uaabb\uaabf\uaac2\uaac2\uaac4\uaac4\uaadd\uaadf\uaae2\uaaec\uaaf4\uaaf6',
-  '\uab03\uab08\uab0b\uab10\uab13\uab18\uab22\uab28\uab2a\uab30\uabc2\uabe4',
-  '\uac02\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902\ufa6f\ufa72\ufadb\ufb02\ufb08',
-  '\ufb15\ufb19\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a\ufb3e\ufb40\ufb40',
-  '\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52\ufd91\ufd94\ufdc9',
-  '\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff23\uff3c\uff43\uff5c\uff68\uffc0',
-  '\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\u0004\u0002CCcc\u0004',
-  '\u0002DDdd\u0004\u0002EEee\u0004\u0002FFff\u0004\u0002HHhh\u0004\u0002',
-  'IIii\u0004\u0002JJjj\u0004\u0002KKkk\u0004\u0002LLll\u0004\u0002MMm',
-  'm\u0004\u0002NNnn\u0004\u0002OOoo\u0004\u0002PPpp\u0004\u0002QQqq\u0004',
-  '\u0002RRrr\u0004\u0002SSss\u0004\u0002TTtt\u0004\u0002UUuu\u0004\u0002',
-  'VVvv\u0004\u0002XXxx\u0004\u0002YYyy\u0004\u0002ZZzz\u0004\u0002[[{',
-  '{\u0004\u0002\\\\||\u0002\u0517\u0002\u0003\u0003\u0002\u0002\u0002',
-  '\u0002\u0005\u0003\u0002\u0002\u0002\u0002\u0007\u0003\u0002\u0002\u0002',
-  '\u0002\t\u0003\u0002\u0002\u0002\u0002\u000b\u0003\u0002\u0002\u0002',
-  '\u0002\r\u0003\u0002\u0002\u0002\u0002\u000f\u0003\u0002\u0002\u0002',
-  '\u0002\u0011\u0003\u0002\u0002\u0002\u0002\u0013\u0003\u0002\u0002\u0002',
-  '\u0002\u0015\u0003\u0002\u0002\u0002\u0002\u0017\u0003\u0002\u0002\u0002',
-  '\u0002\u0019\u0003\u0002\u0002\u0002\u0002\u001b\u0003\u0002\u0002\u0002',
-  '\u0002\u001d\u0003\u0002\u0002\u0002\u0002\u001f\u0003\u0002\u0002\u0002',
-  '\u0002!\u0003\u0002\u0002\u0002\u0002#\u0003\u0002\u0002\u0002\u0002',
-  "%\u0003\u0002\u0002\u0002\u0002'\u0003\u0002\u0002\u0002\u0002)\u0003",
-  '\u0002\u0002\u0002\u0002+\u0003\u0002\u0002\u0002\u0002-\u0003\u0002',
-  '\u0002\u0002\u0002/\u0003\u0002\u0002\u0002\u00021\u0003\u0002\u0002',
-  '\u0002\u00023\u0003\u0002\u0002\u0002\u00025\u0003\u0002\u0002\u0002',
-  '\u00027\u0003\u0002\u0002\u0002\u00029\u0003\u0002\u0002\u0002\u0002',
-  ';\u0003\u0002\u0002\u0002\u0002=\u0003\u0002\u0002\u0002\u0002?\u0003',
-  '\u0002\u0002\u0002\u0002A\u0003\u0002\u0002\u0002\u0002C\u0003\u0002',
-  '\u0002\u0002\u0002E\u0003\u0002\u0002\u0002\u0002G\u0003\u0002\u0002',
-  '\u0002\u0002I\u0003\u0002\u0002\u0002\u0002K\u0003\u0002\u0002\u0002',
-  '\u0002M\u0003\u0002\u0002\u0002\u0002O\u0003\u0002\u0002\u0002\u0002',
-  'Q\u0003\u0002\u0002\u0002\u0002S\u0003\u0002\u0002\u0002\u0002U\u0003',
-  '\u0002\u0002\u0002\u0002W\u0003\u0002\u0002\u0002\u0002Y\u0003\u0002',
-  '\u0002\u0002\u0002[\u0003\u0002\u0002\u0002\u0002]\u0003\u0002\u0002',
-  '\u0002\u0002_\u0003\u0002\u0002\u0002\u0002a\u0003\u0002\u0002\u0002',
-  '\u0002c\u0003\u0002\u0002\u0002\u0002e\u0003\u0002\u0002\u0002\u0002',
-  'g\u0003\u0002\u0002\u0002\u0002i\u0003\u0002\u0002\u0002\u0002k\u0003',
-  '\u0002\u0002\u0002\u0002m\u0003\u0002\u0002\u0002\u0002o\u0003\u0002',
-  '\u0002\u0002\u0002q\u0003\u0002\u0002\u0002\u0002s\u0003\u0002\u0002',
-  '\u0002\u0002u\u0003\u0002\u0002\u0002\u0002w\u0003\u0002\u0002\u0002',
-  '\u0002y\u0003\u0002\u0002\u0002\u0002{\u0003\u0002\u0002\u0002\u0002',
-  '}\u0003\u0002\u0002\u0002\u0002\u007f\u0003\u0002\u0002\u0002\u0002',
-  '\u0081\u0003\u0002\u0002\u0002\u0002\u0083\u0003\u0002\u0002\u0002\u0002',
-  '\u0085\u0003\u0002\u0002\u0002\u0002\u0087\u0003\u0002\u0002\u0002\u0002',
-  '\u0089\u0003\u0002\u0002\u0002\u0002\u008b\u0003\u0002\u0002\u0002\u0002',
-  '\u008d\u0003\u0002\u0002\u0002\u0002\u008f\u0003\u0002\u0002\u0002\u0002',
-  '\u0091\u0003\u0002\u0002\u0002\u0002\u0093\u0003\u0002\u0002\u0002\u0002',
-  '\u0095\u0003\u0002\u0002\u0002\u0002\u0097\u0003\u0002\u0002\u0002\u0002',
-  '\u0099\u0003\u0002\u0002\u0002\u0002\u009b\u0003\u0002\u0002\u0002\u0002',
-  '\u009d\u0003\u0002\u0002\u0002\u0002\u009f\u0003\u0002\u0002\u0002\u0002',
-  '\u00a1\u0003\u0002\u0002\u0002\u0002\u00a3\u0003\u0002\u0002\u0002\u0002',
-  '\u00a5\u0003\u0002\u0002\u0002\u0002\u00a7\u0003\u0002\u0002\u0002\u0002',
-  '\u00a9\u0003\u0002\u0002\u0002\u0002\u00ab\u0003\u0002\u0002\u0002\u0002',
-  '\u00ad\u0003\u0002\u0002\u0002\u0002\u00af\u0003\u0002\u0002\u0002\u0002',
-  '\u00b1\u0003\u0002\u0002\u0002\u0002\u00b3\u0003\u0002\u0002\u0002\u0002',
-  '\u00b5\u0003\u0002\u0002\u0002\u0002\u00b7\u0003\u0002\u0002\u0002\u0002',
-  '\u00b9\u0003\u0002\u0002\u0002\u0002\u00bb\u0003\u0002\u0002\u0002\u0002',
-  '\u00bd\u0003\u0002\u0002\u0002\u0002\u00bf\u0003\u0002\u0002\u0002\u0002',
-  '\u00c1\u0003\u0002\u0002\u0002\u0002\u00c3\u0003\u0002\u0002\u0002\u0002',
-  '\u00c5\u0003\u0002\u0002\u0002\u0002\u00c7\u0003\u0002\u0002\u0002\u0002',
-  '\u00c9\u0003\u0002\u0002\u0002\u0002\u00cb\u0003\u0002\u0002\u0002\u0002',
-  '\u00cd\u0003\u0002\u0002\u0002\u0002\u00cf\u0003\u0002\u0002\u0002\u0002',
-  '\u00d1\u0003\u0002\u0002\u0002\u0002\u00d3\u0003\u0002\u0002\u0002\u0002',
-  '\u00d5\u0003\u0002\u0002\u0002\u0002\u00d7\u0003\u0002\u0002\u0002\u0002',
-  '\u00d9\u0003\u0002\u0002\u0002\u0002\u00db\u0003\u0002\u0002\u0002\u0002',
-  '\u00dd\u0003\u0002\u0002\u0002\u0002\u00df\u0003\u0002\u0002\u0002\u0002',
-  '\u00e1\u0003\u0002\u0002\u0002\u0002\u00e3\u0003\u0002\u0002\u0002\u0002',
-  '\u00e5\u0003\u0002\u0002\u0002\u0002\u00e7\u0003\u0002\u0002\u0002\u0002',
-  '\u00e9\u0003\u0002\u0002\u0002\u0002\u00eb\u0003\u0002\u0002\u0002\u0002',
-  '\u00ed\u0003\u0002\u0002\u0002\u0002\u00ef\u0003\u0002\u0002\u0002\u0002',
-  '\u00f1\u0003\u0002\u0002\u0002\u0002\u00f3\u0003\u0002\u0002\u0002\u0002',
-  '\u00f5\u0003\u0002\u0002\u0002\u0002\u00f7\u0003\u0002\u0002\u0002\u0002',
-  '\u00f9\u0003\u0002\u0002\u0002\u0002\u00fb\u0003\u0002\u0002\u0002\u0002',
-  '\u00fd\u0003\u0002\u0002\u0002\u0002\u00ff\u0003\u0002\u0002\u0002\u0002',
-  '\u0101\u0003\u0002\u0002\u0002\u0002\u0103\u0003\u0002\u0002\u0002\u0002',
-  '\u0105\u0003\u0002\u0002\u0002\u0002\u0107\u0003\u0002\u0002\u0002\u0002',
-  '\u0109\u0003\u0002\u0002\u0002\u0002\u010b\u0003\u0002\u0002\u0002\u0002',
-  '\u010d\u0003\u0002\u0002\u0002\u0002\u010f\u0003\u0002\u0002\u0002\u0002',
-  '\u0111\u0003\u0002\u0002\u0002\u0002\u0113\u0003\u0002\u0002\u0002\u0002',
-  '\u0115\u0003\u0002\u0002\u0002\u0002\u0117\u0003\u0002\u0002\u0002\u0002',
-  '\u0119\u0003\u0002\u0002\u0002\u0002\u011b\u0003\u0002\u0002\u0002\u0002',
-  '\u011d\u0003\u0002\u0002\u0002\u0002\u011f\u0003\u0002\u0002\u0002\u0002',
-  '\u0121\u0003\u0002\u0002\u0002\u0002\u0123\u0003\u0002\u0002\u0002\u0002',
-  '\u0125\u0003\u0002\u0002\u0002\u0002\u0127\u0003\u0002\u0002\u0002\u0002',
-  '\u0129\u0003\u0002\u0002\u0002\u0002\u012b\u0003\u0002\u0002\u0002\u0002',
-  '\u012d\u0003\u0002\u0002\u0002\u0002\u012f\u0003\u0002\u0002\u0002\u0002',
-  '\u0131\u0003\u0002\u0002\u0002\u0002\u0133\u0003\u0002\u0002\u0002\u0002',
-  '\u0135\u0003\u0002\u0002\u0002\u0003\u0185\u0003\u0002\u0002\u0002\u0005',
-  '\u0187\u0003\u0002\u0002\u0002\u0007\u0189\u0003\u0002\u0002\u0002\t',
-  '\u018b\u0003\u0002\u0002\u0002\u000b\u018e\u0003\u0002\u0002\u0002\r',
-  '\u0192\u0003\u0002\u0002\u0002\u000f\u0194\u0003\u0002\u0002\u0002\u0011',
-  '\u0196\u0003\u0002\u0002\u0002\u0013\u0198\u0003\u0002\u0002\u0002\u0015',
-  '\u019a\u0003\u0002\u0002\u0002\u0017\u019c\u0003\u0002\u0002\u0002\u0019',
-  '\u019e\u0003\u0002\u0002\u0002\u001b\u01a0\u0003\u0002\u0002\u0002\u001d',
-  '\u01a2\u0003\u0002\u0002\u0002\u001f\u01a4\u0003\u0002\u0002\u0002!',
-  '\u01a6\u0003\u0002\u0002\u0002#\u01a8\u0003\u0002\u0002\u0002%\u01aa',
-  "\u0003\u0002\u0002\u0002'\u01ac\u0003\u0002\u0002\u0002)\u01ae\u0003",
-  '\u0002\u0002\u0002+\u01b0\u0003\u0002\u0002\u0002-\u01b3\u0003\u0002',
-  '\u0002\u0002/\u01b5\u0003\u0002\u0002\u00021\u01b7\u0003\u0002\u0002',
-  '\u00023\u01ba\u0003\u0002\u0002\u00025\u01bc\u0003\u0002\u0002\u0002',
-  '7\u01be\u0003\u0002\u0002\u00029\u01c1\u0003\u0002\u0002\u0002;\u01c4',
-  '\u0003\u0002\u0002\u0002=\u01c7\u0003\u0002\u0002\u0002?\u01c9\u0003',
-  '\u0002\u0002\u0002A\u01cb\u0003\u0002\u0002\u0002C\u01ce\u0003\u0002',
-  '\u0002\u0002E\u01d1\u0003\u0002\u0002\u0002G\u01d3\u0003\u0002\u0002',
-  '\u0002I\u01d5\u0003\u0002\u0002\u0002K\u01d7\u0003\u0002\u0002\u0002',
-  'M\u01d9\u0003\u0002\u0002\u0002O\u01db\u0003\u0002\u0002\u0002Q\u01dd',
-  '\u0003\u0002\u0002\u0002S\u01df\u0003\u0002\u0002\u0002U\u01e1\u0003',
-  '\u0002\u0002\u0002W\u01e3\u0003\u0002\u0002\u0002Y\u01e5\u0003\u0002',
-  '\u0002\u0002[\u01e7\u0003\u0002\u0002\u0002]\u01e9\u0003\u0002\u0002',
-  '\u0002_\u01eb\u0003\u0002\u0002\u0002a\u01ed\u0003\u0002\u0002\u0002',
-  'c\u01ef\u0003\u0002\u0002\u0002e\u01f1\u0003\u0002\u0002\u0002g\u01f3',
-  '\u0003\u0002\u0002\u0002i\u01f5\u0003\u0002\u0002\u0002k\u01f7\u0003',
-  '\u0002\u0002\u0002m\u01f9\u0003\u0002\u0002\u0002o\u0200\u0003\u0002',
-  '\u0002\u0002q\u0208\u0003\u0002\u0002\u0002s\u0210\u0003\u0002\u0002',
-  '\u0002u\u0216\u0003\u0002\u0002\u0002w\u021f\u0003\u0002\u0002\u0002',
-  'y\u0226\u0003\u0002\u0002\u0002{\u022c\u0003\u0002\u0002\u0002}\u0230',
-  '\u0003\u0002\u0002\u0002\u007f\u0237\u0003\u0002\u0002\u0002\u0081\u023c',
-  '\u0003\u0002\u0002\u0002\u0083\u0242\u0003\u0002\u0002\u0002\u0085\u0245',
-  '\u0003\u0002\u0002\u0002\u0087\u0250\u0003\u0002\u0002\u0002\u0089\u0257',
-  '\u0003\u0002\u0002\u0002\u008b\u025a\u0003\u0002\u0002\u0002\u008d\u0261',
-  '\u0003\u0002\u0002\u0002\u008f\u0268\u0003\u0002\u0002\u0002\u0091\u026d',
-  '\u0003\u0002\u0002\u0002\u0093\u0271\u0003\u0002\u0002\u0002\u0095\u0276',
-  '\u0003\u0002\u0002\u0002\u0097\u027e\u0003\u0002\u0002\u0002\u0099\u0283',
-  '\u0003\u0002\u0002\u0002\u009b\u0286\u0003\u0002\u0002\u0002\u009d\u0296',
-  '\u0003\u0002\u0002\u0002\u009f\u029f\u0003\u0002\u0002\u0002\u00a1\u02a5',
-  '\u0003\u0002\u0002\u0002\u00a3\u02ac\u0003\u0002\u0002\u0002\u00a5\u02b2',
-  '\u0003\u0002\u0002\u0002\u00a7\u02b6\u0003\u0002\u0002\u0002\u00a9\u02bd',
-  '\u0003\u0002\u0002\u0002\u00ab\u02c4\u0003\u0002\u0002\u0002\u00ad\u02cb',
-  '\u0003\u0002\u0002\u0002\u00af\u02d3\u0003\u0002\u0002\u0002\u00b1\u02d6',
-  '\u0003\u0002\u0002\u0002\u00b3\u02df\u0003\u0002\u0002\u0002\u00b5\u02e6',
-  '\u0003\u0002\u0002\u0002\u00b7\u02ec\u0003\u0002\u0002\u0002\u00b9\u02ef',
-  '\u0003\u0002\u0002\u0002\u00bb\u02f4\u0003\u0002\u0002\u0002\u00bd\u02fa',
-  '\u0003\u0002\u0002\u0002\u00bf\u0304\u0003\u0002\u0002\u0002\u00c1\u0308',
-  '\u0003\u0002\u0002\u0002\u00c3\u0313\u0003\u0002\u0002\u0002\u00c5\u0318',
-  '\u0003\u0002\u0002\u0002\u00c7\u031d\u0003\u0002\u0002\u0002\u00c9\u0322',
-  '\u0003\u0002\u0002\u0002\u00cb\u0328\u0003\u0002\u0002\u0002\u00cd\u032d',
-  '\u0003\u0002\u0002\u0002\u00cf\u033a\u0003\u0002\u0002\u0002\u00d1\u033e',
-  '\u0003\u0002\u0002\u0002\u00d3\u0344\u0003\u0002\u0002\u0002\u00d5\u0351',
-  '\u0003\u0002\u0002\u0002\u00d7\u0362\u0003\u0002\u0002\u0002\u00d9\u0365',
-  '\u0003\u0002\u0002\u0002\u00db\u0369\u0003\u0002\u0002\u0002\u00dd\u036d',
-  '\u0003\u0002\u0002\u0002\u00df\u0371\u0003\u0002\u0002\u0002\u00e1\u0378',
-  '\u0003\u0002\u0002\u0002\u00e3\u037d\u0003\u0002\u0002\u0002\u00e5\u0386',
-  '\u0003\u0002\u0002\u0002\u00e7\u038b\u0003\u0002\u0002\u0002\u00e9\u0391',
-  '\u0003\u0002\u0002\u0002\u00eb\u0398\u0003\u0002\u0002\u0002\u00ed\u03a0',
-  '\u0003\u0002\u0002\u0002\u00ef\u03a4\u0003\u0002\u0002\u0002\u00f1\u03a9',
-  '\u0003\u0002\u0002\u0002\u00f3\u03b0\u0003\u0002\u0002\u0002\u00f5\u03b5',
-  '\u0003\u0002\u0002\u0002\u00f7\u03bb\u0003\u0002\u0002\u0002\u00f9\u03c2',
-  '\u0003\u0002\u0002\u0002\u00fb\u03c7\u0003\u0002\u0002\u0002\u00fd\u03cc',
-  '\u0003\u0002\u0002\u0002\u00ff\u03d0\u0003\u0002\u0002\u0002\u0101\u03d5',
-  '\u0003\u0002\u0002\u0002\u0103\u03da\u0003\u0002\u0002\u0002\u0105\u03df',
-  '\u0003\u0002\u0002\u0002\u0107\u03e5\u0003\u0002\u0002\u0002\u0109\u0403',
-  '\u0003\u0002\u0002\u0002\u010b\u0408\u0003\u0002\u0002\u0002\u010d\u040c',
-  '\u0003\u0002\u0002\u0002\u010f\u0420\u0003\u0002\u0002\u0002\u0111\u0430',
-  '\u0003\u0002\u0002\u0002\u0113\u0432\u0003\u0002\u0002\u0002\u0115\u0439',
-  '\u0003\u0002\u0002\u0002\u0117\u043d\u0003\u0002\u0002\u0002\u0119\u0441',
-  '\u0003\u0002\u0002\u0002\u011b\u0445\u0003\u0002\u0002\u0002\u011d\u0447',
-  '\u0003\u0002\u0002\u0002\u011f\u044b\u0003\u0002\u0002\u0002\u0121\u044d',
-  '\u0003\u0002\u0002\u0002\u0123\u0465\u0003\u0002\u0002\u0002\u0125\u0473',
-  '\u0003\u0002\u0002\u0002\u0127\u047c\u0003\u0002\u0002\u0002\u0129\u0485',
-  '\u0003\u0002\u0002\u0002\u012b\u0489\u0003\u0002\u0002\u0002\u012d\u048b',
-  '\u0003\u0002\u0002\u0002\u012f\u0497\u0003\u0002\u0002\u0002\u0131\u04a7',
-  '\u0003\u0002\u0002\u0002\u0133\u04bd\u0003\u0002\u0002\u0002\u0135\u04bf',
-  '\u0003\u0002\u0002\u0002\u0137\u04c1\u0003\u0002\u0002\u0002\u0139\u04c3',
-  '\u0003\u0002\u0002\u0002\u013b\u04c5\u0003\u0002\u0002\u0002\u013d\u04c7',
-  '\u0003\u0002\u0002\u0002\u013f\u04c9\u0003\u0002\u0002\u0002\u0141\u04cb',
-  '\u0003\u0002\u0002\u0002\u0143\u04cd\u0003\u0002\u0002\u0002\u0145\u04cf',
-  '\u0003\u0002\u0002\u0002\u0147\u04d1\u0003\u0002\u0002\u0002\u0149\u04d3',
-  '\u0003\u0002\u0002\u0002\u014b\u04d5\u0003\u0002\u0002\u0002\u014d\u04d7',
-  '\u0003\u0002\u0002\u0002\u014f\u04d9\u0003\u0002\u0002\u0002\u0151\u04db',
-  '\u0003\u0002\u0002\u0002\u0153\u04dd\u0003\u0002\u0002\u0002\u0155\u04df',
-  '\u0003\u0002\u0002\u0002\u0157\u04e1\u0003\u0002\u0002\u0002\u0159\u04e3',
-  '\u0003\u0002\u0002\u0002\u015b\u04e5\u0003\u0002\u0002\u0002\u015d\u04e7',
-  '\u0003\u0002\u0002\u0002\u015f\u04e9\u0003\u0002\u0002\u0002\u0161\u04eb',
-  '\u0003\u0002\u0002\u0002\u0163\u04ed\u0003\u0002\u0002\u0002\u0165\u04ef',
-  '\u0003\u0002\u0002\u0002\u0167\u04f1\u0003\u0002\u0002\u0002\u0169\u04f3',
-  '\u0003\u0002\u0002\u0002\u016b\u04f5\u0003\u0002\u0002\u0002\u016d\u04f7',
-  '\u0003\u0002\u0002\u0002\u016f\u04f9\u0003\u0002\u0002\u0002\u0171\u04fb',
-  '\u0003\u0002\u0002\u0002\u0173\u04fd\u0003\u0002\u0002\u0002\u0175\u04ff',
-  '\u0003\u0002\u0002\u0002\u0177\u0501\u0003\u0002\u0002\u0002\u0179\u0503',
-  '\u0003\u0002\u0002\u0002\u017b\u0505\u0003\u0002\u0002\u0002\u017d\u0507',
-  '\u0003\u0002\u0002\u0002\u017f\u0509\u0003\u0002\u0002\u0002\u0181\u050b',
-  '\u0003\u0002\u0002\u0002\u0183\u050d\u0003\u0002\u0002\u0002\u0185\u0186',
-  '\u0007=\u0002\u0002\u0186\u0004\u0003\u0002\u0002\u0002\u0187\u0188',
-  '\u0007<\u0002\u0002\u0188\u0006\u0003\u0002\u0002\u0002\u0189\u018a',
-  '\u0007/\u0002\u0002\u018a\b\u0003\u0002\u0002\u0002\u018b\u018c\u0007',
-  '?\u0002\u0002\u018c\u018d\u0007@\u0002\u0002\u018d\n\u0003\u0002\u0002',
-  '\u0002\u018e\u018f\u0007<\u0002\u0002\u018f\u0190\u00071\u0002\u0002',
-  '\u0190\u0191\u00071\u0002\u0002\u0191\f\u0003\u0002\u0002\u0002\u0192',
-  '\u0193\u00071\u0002\u0002\u0193\u000e\u0003\u0002\u0002\u0002\u0194',
-  '\u0195\u00070\u0002\u0002\u0195\u0010\u0003\u0002\u0002\u0002\u0196',
-  '\u0197\u0007B\u0002\u0002\u0197\u0012\u0003\u0002\u0002\u0002\u0198',
-  '\u0199\u0007%\u0002\u0002\u0199\u0014\u0003\u0002\u0002\u0002\u019a',
-  '\u019b\u0007A\u0002\u0002\u019b\u0016\u0003\u0002\u0002\u0002\u019c',
-  '\u019d\u0007(\u0002\u0002\u019d\u0018\u0003\u0002\u0002\u0002\u019e',
-  '\u019f\u0007?\u0002\u0002\u019f\u001a\u0003\u0002\u0002\u0002\u01a0',
-  '\u01a1\u0007-\u0002\u0002\u01a1\u001c\u0003\u0002\u0002\u0002\u01a2',
-  '\u01a3\u0007}\u0002\u0002\u01a3\u001e\u0003\u0002\u0002\u0002\u01a4',
-  '\u01a5\u0007.\u0002\u0002\u01a5 \u0003\u0002\u0002\u0002\u01a6\u01a7',
-  '\u0007\u007f\u0002\u0002\u01a7"\u0003\u0002\u0002\u0002\u01a8\u01a9',
-  '\u0007]\u0002\u0002\u01a9$\u0003\u0002\u0002\u0002\u01aa\u01ab\u0007',
-  '_\u0002\u0002\u01ab&\u0003\u0002\u0002\u0002\u01ac\u01ad\u0007*\u0002',
-  '\u0002\u01ad(\u0003\u0002\u0002\u0002\u01ae\u01af\u0007+\u0002\u0002',
-  '\u01af*\u0003\u0002\u0002\u0002\u01b0\u01b1\u0007-\u0002\u0002\u01b1',
-  '\u01b2\u0007?\u0002\u0002\u01b2,\u0003\u0002\u0002\u0002\u01b3\u01b4',
-  '\u0007~\u0002\u0002\u01b4.\u0003\u0002\u0002\u0002\u01b5\u01b6\u0007',
-  ',\u0002\u0002\u01b60\u0003\u0002\u0002\u0002\u01b7\u01b8\u00070\u0002',
-  '\u0002\u01b8\u01b9\u00070\u0002\u0002\u01b92\u0003\u0002\u0002\u0002',
-  "\u01ba\u01bb\u0007'\u0002\u0002\u01bb4\u0003\u0002\u0002\u0002\u01bc",
-  '\u01bd\u0007`\u0002\u0002\u01bd6\u0003\u0002\u0002\u0002\u01be\u01bf',
-  '\u0007?\u0002\u0002\u01bf\u01c0\u0007\u0080\u0002\u0002\u01c08\u0003',
-  '\u0002\u0002\u0002\u01c1\u01c2\u0007>\u0002\u0002\u01c2\u01c3\u0007',
-  '@\u0002\u0002\u01c3:\u0003\u0002\u0002\u0002\u01c4\u01c5\u0007#\u0002',
-  '\u0002\u01c5\u01c6\u0007?\u0002\u0002\u01c6<\u0003\u0002\u0002\u0002',
-  '\u01c7\u01c8\u0007>\u0002\u0002\u01c8>\u0003\u0002\u0002\u0002\u01c9',
-  '\u01ca\u0007@\u0002\u0002\u01ca@\u0003\u0002\u0002\u0002\u01cb\u01cc',
-  '\u0007>\u0002\u0002\u01cc\u01cd\u0007?\u0002\u0002\u01cdB\u0003\u0002',
-  '\u0002\u0002\u01ce\u01cf\u0007@\u0002\u0002\u01cf\u01d0\u0007?\u0002',
-  '\u0002\u01d0D\u0003\u0002\u0002\u0002\u01d1\u01d2\u0007&\u0002\u0002',
-  '\u01d2F\u0003\u0002\u0002\u0002\u01d3\u01d4\u0007\u27ea\u0002\u0002',
-  '\u01d4H\u0003\u0002\u0002\u0002\u01d5\u01d6\u0007\u300a\u0002\u0002',
-  '\u01d6J\u0003\u0002\u0002\u0002\u01d7\u01d8\u0007\ufe66\u0002\u0002',
-  '\u01d8L\u0003\u0002\u0002\u0002\u01d9\u01da\u0007\uff1e\u0002\u0002',
-  '\u01daN\u0003\u0002\u0002\u0002\u01db\u01dc\u0007\u27eb\u0002\u0002',
-  '\u01dcP\u0003\u0002\u0002\u0002\u01dd\u01de\u0007\u300b\u0002\u0002',
-  '\u01deR\u0003\u0002\u0002\u0002\u01df\u01e0\u0007\ufe67\u0002\u0002',
-  '\u01e0T\u0003\u0002\u0002\u0002\u01e1\u01e2\u0007\uff20\u0002\u0002',
-  '\u01e2V\u0003\u0002\u0002\u0002\u01e3\u01e4\u0007\u00af\u0002\u0002',
-  '\u01e4X\u0003\u0002\u0002\u0002\u01e5\u01e6\u0007\u2012\u0002\u0002',
-  '\u01e6Z\u0003\u0002\u0002\u0002\u01e7\u01e8\u0007\u2013\u0002\u0002',
-  '\u01e8\\\u0003\u0002\u0002\u0002\u01e9\u01ea\u0007\u2014\u0002\u0002',
-  '\u01ea^\u0003\u0002\u0002\u0002\u01eb\u01ec\u0007\u2015\u0002\u0002',
-  '\u01ec`\u0003\u0002\u0002\u0002\u01ed\u01ee\u0007\u2016\u0002\u0002',
-  '\u01eeb\u0003\u0002\u0002\u0002\u01ef\u01f0\u0007\u2017\u0002\u0002',
-  '\u01f0d\u0003\u0002\u0002\u0002\u01f1\u01f2\u0007\u2214\u0002\u0002',
-  '\u01f2f\u0003\u0002\u0002\u0002\u01f3\u01f4\u0007\ufe5a\u0002\u0002',
-  '\u01f4h\u0003\u0002\u0002\u0002\u01f5\u01f6\u0007\ufe65\u0002\u0002',
-  '\u01f6j\u0003\u0002\u0002\u0002\u01f7\u01f8\u0007\uff0f\u0002\u0002',
-  '\u01f8l\u0003\u0002\u0002\u0002\u01f9\u01fa\u0005\u0155\u00ab\u0002',
-  '\u01fa\u01fb\u0005\u0181\u00c1\u0002\u01fb\u01fc\u0005\u016f\u00b8\u0002',
-  '\u01fc\u01fd\u0005\u015f\u00b0\u0002\u01fd\u01fe\u0005\u0159\u00ad\u0002',
-  '\u01fe\u01ff\u0005\u0173\u00ba\u0002\u01ffn\u0003\u0002\u0002\u0002',
-  '\u0200\u0201\u0005\u0159\u00ad\u0002\u0201\u0202\u0005\u017f\u00c0\u0002',
-  '\u0202\u0203\u0005\u016f\u00b8\u0002\u0203\u0204\u0005\u0167\u00b4\u0002',
-  '\u0204\u0205\u0005\u0151\u00a9\u0002\u0205\u0206\u0005\u0161\u00b1\u0002',
-  '\u0206\u0207\u0005\u016b\u00b6\u0002\u0207p\u0003\u0002\u0002\u0002',
-  '\u0208\u0209\u0005\u016f\u00b8\u0002\u0209\u020a\u0005\u0173\u00ba\u0002',
-  '\u020a\u020b\u0005\u016d\u00b7\u0002\u020b\u020c\u0005\u015b\u00ae\u0002',
-  '\u020c\u020d\u0005\u0161\u00b1\u0002\u020d\u020e\u0005\u0167\u00b4\u0002',
-  '\u020e\u020f\u0005\u0159\u00ad\u0002\u020fr\u0003\u0002\u0002\u0002',
-  '\u0210\u0211\u0005\u0179\u00bd\u0002\u0211\u0212\u0005\u0175\u00bb\u0002',
-  '\u0212\u0213\u0005\u0161\u00b1\u0002\u0213\u0214\u0005\u016b\u00b6\u0002',
-  '\u0214\u0215\u0005\u015d\u00af\u0002\u0215t\u0003\u0002\u0002\u0002',
-  '\u0216\u0217\u0005\u016f\u00b8\u0002\u0217\u0218\u0005\u0159\u00ad\u0002',
-  '\u0218\u0219\u0005\u0173\u00ba\u0002\u0219\u021a\u0005\u0161\u00b1\u0002',
-  '\u021a\u021b\u0005\u016d\u00b7\u0002\u021b\u021c\u0005\u0157\u00ac\u0002',
-  '\u021c\u021d\u0005\u0161\u00b1\u0002\u021d\u021e\u0005\u0155\u00ab\u0002',
-  '\u021ev\u0003\u0002\u0002\u0002\u021f\u0220\u0005\u0155\u00ab\u0002',
-  '\u0220\u0221\u0005\u016d\u00b7\u0002\u0221\u0222\u0005\u0169\u00b5\u0002',
-  '\u0222\u0223\u0005\u0169\u00b5\u0002\u0223\u0224\u0005\u0161\u00b1\u0002',
-  '\u0224\u0225\u0005\u0177\u00bc\u0002\u0225x\u0003\u0002\u0002\u0002',
-  '\u0226\u0227\u0005\u0179\u00bd\u0002\u0227\u0228\u0005\u016b\u00b6\u0002',
-  '\u0228\u0229\u0005\u0161\u00b1\u0002\u0229\u022a\u0005\u016d\u00b7\u0002',
-  '\u022a\u022b\u0005\u016b\u00b6\u0002\u022bz\u0003\u0002\u0002\u0002',
-  '\u022c\u022d\u0005\u0151\u00a9\u0002\u022d\u022e\u0005\u0167\u00b4\u0002',
-  '\u022e\u022f\u0005\u0167\u00b4\u0002\u022f|\u0003\u0002\u0002\u0002',
-  '\u0230\u0231\u0005\u0155\u00ab\u0002\u0231\u0232\u0005\u0173\u00ba\u0002',
-  '\u0232\u0233\u0005\u0159\u00ad\u0002\u0233\u0234\u0005\u0151\u00a9\u0002',
-  '\u0234\u0235\u0005\u0177\u00bc\u0002\u0235\u0236\u0005\u0159\u00ad\u0002',
-  '\u0236~\u0003\u0002\u0002\u0002\u0237\u0238\u0005\u0157\u00ac\u0002',
-  '\u0238\u0239\u0005\u0173\u00ba\u0002\u0239\u023a\u0005\u016d\u00b7\u0002',
-  '\u023a\u023b\u0005\u016f\u00b8\u0002\u023b\u0080\u0003\u0002\u0002\u0002',
-  '\u023c\u023d\u0005\u0161\u00b1\u0002\u023d\u023e\u0005\u016b\u00b6\u0002',
-  '\u023e\u023f\u0005\u0157\u00ac\u0002\u023f\u0240\u0005\u0159\u00ad\u0002',
-  '\u0240\u0241\u0005\u017f\u00c0\u0002\u0241\u0082\u0003\u0002\u0002\u0002',
-  '\u0242\u0243\u0005\u016d\u00b7\u0002\u0243\u0244\u0005\u016b\u00b6\u0002',
-  '\u0244\u0084\u0003\u0002\u0002\u0002\u0245\u0246\u0005\u0155\u00ab\u0002',
-  '\u0246\u0247\u0005\u016d\u00b7\u0002\u0247\u0248\u0005\u016b\u00b6\u0002',
-  '\u0248\u0249\u0005\u0175\u00bb\u0002\u0249\u024a\u0005\u0177\u00bc\u0002',
-  '\u024a\u024b\u0005\u0173\u00ba\u0002\u024b\u024c\u0005\u0151\u00a9\u0002',
-  '\u024c\u024d\u0005\u0161\u00b1\u0002\u024d\u024e\u0005\u016b\u00b6\u0002',
-  '\u024e\u024f\u0005\u0177\u00bc\u0002\u024f\u0086\u0003\u0002\u0002\u0002',
-  '\u0250\u0251\u0005\u0151\u00a9\u0002\u0251\u0252\u0005\u0175\u00bb\u0002',
-  '\u0252\u0253\u0005\u0175\u00bb\u0002\u0253\u0254\u0005\u0159\u00ad\u0002',
-  '\u0254\u0255\u0005\u0173\u00ba\u0002\u0255\u0256\u0005\u0177\u00bc\u0002',
-  '\u0256\u0088\u0003\u0002\u0002\u0002\u0257\u0258\u0005\u0161\u00b1\u0002',
-  '\u0258\u0259\u0005\u0175\u00bb\u0002\u0259\u008a\u0003\u0002\u0002\u0002',
-  '\u025a\u025b\u0005\u0179\u00bd\u0002\u025b\u025c\u0005\u016b\u00b6\u0002',
-  '\u025c\u025d\u0005\u0161\u00b1\u0002\u025d\u025e\u0005\u0171\u00b9\u0002',
-  '\u025e\u025f\u0005\u0179\u00bd\u0002\u025f\u0260\u0005\u0159\u00ad\u0002',
-  '\u0260\u008c\u0003\u0002\u0002\u0002\u0261\u0262\u0005\u0159\u00ad\u0002',
-  '\u0262\u0263\u0005\u017f\u00c0\u0002\u0263\u0264\u0005\u0161\u00b1\u0002',
-  '\u0264\u0265\u0005\u0175\u00bb\u0002\u0265\u0266\u0005\u0177\u00bc\u0002',
-  '\u0266\u0267\u0005\u0175\u00bb\u0002\u0267\u008e\u0003\u0002\u0002\u0002',
-  '\u0268\u0269\u0005\u0167\u00b4\u0002\u0269\u026a\u0005\u016d\u00b7\u0002',
-  '\u026a\u026b\u0005\u0151\u00a9\u0002\u026b\u026c\u0005\u0157\u00ac\u0002',
-  '\u026c\u0090\u0003\u0002\u0002\u0002\u026d\u026e\u0005\u0155\u00ab\u0002',
-  '\u026e\u026f\u0005\u0175\u00bb\u0002\u026f\u0270\u0005\u017b\u00be\u0002',
-  '\u0270\u0092\u0003\u0002\u0002\u0002\u0271\u0272\u0005\u017d\u00bf\u0002',
-  '\u0272\u0273\u0005\u0161\u00b1\u0002\u0273\u0274\u0005\u0177\u00bc\u0002',
-  '\u0274\u0275\u0005\u015f\u00b0\u0002\u0275\u0094\u0003\u0002\u0002\u0002',
-  '\u0276\u0277\u0005\u015f\u00b0\u0002\u0277\u0278\u0005\u0159\u00ad\u0002',
-  '\u0278\u0279\u0005\u0151\u00a9\u0002\u0279\u027a\u0005\u0157\u00ac\u0002',
-  '\u027a\u027b\u0005\u0159\u00ad\u0002\u027b\u027c\u0005\u0173\u00ba\u0002',
-  '\u027c\u027d\u0005\u0175\u00bb\u0002\u027d\u0096\u0003\u0002\u0002\u0002',
-  '\u027e\u027f\u0005\u015b\u00ae\u0002\u027f\u0280\u0005\u0173\u00ba\u0002',
-  '\u0280\u0281\u0005\u016d\u00b7\u0002\u0281\u0282\u0005\u0169\u00b5\u0002',
-  '\u0282\u0098\u0003\u0002\u0002\u0002\u0283\u0284\u0005\u0151\u00a9\u0002',
-  '\u0284\u0285\u0005\u0175\u00bb\u0002\u0285\u009a\u0003\u0002\u0002\u0002',
-  '\u0286\u0287\u0005\u015b\u00ae\u0002\u0287\u0288\u0005\u0161\u00b1\u0002',
-  '\u0288\u0289\u0005\u0159\u00ad\u0002\u0289\u028a\u0005\u0167\u00b4\u0002',
-  '\u028a\u028b\u0005\u0157\u00ac\u0002\u028b\u028c\u0005\u0177\u00bc\u0002',
-  '\u028c\u028d\u0005\u0159\u00ad\u0002\u028d\u028e\u0005\u0173\u00ba\u0002',
-  '\u028e\u028f\u0005\u0169\u00b5\u0002\u028f\u0290\u0005\u0161\u00b1\u0002',
-  '\u0290\u0291\u0005\u016b\u00b6\u0002\u0291\u0292\u0005\u0151\u00a9\u0002',
-  '\u0292\u0293\u0005\u0177\u00bc\u0002\u0293\u0294\u0005\u016d\u00b7\u0002',
-  '\u0294\u0295\u0005\u0173\u00ba\u0002\u0295\u009c\u0003\u0002\u0002\u0002',
-  '\u0296\u0297\u0005\u016d\u00b7\u0002\u0297\u0298\u0005\u016f\u00b8\u0002',
-  '\u0298\u0299\u0005\u0177\u00bc\u0002\u0299\u029a\u0005\u0161\u00b1\u0002',
-  '\u029a\u029b\u0005\u016d\u00b7\u0002\u029b\u029c\u0005\u016b\u00b6\u0002',
-  '\u029c\u029d\u0005\u0151\u00a9\u0002\u029d\u029e\u0005\u0167\u00b4\u0002',
-  '\u029e\u009e\u0003\u0002\u0002\u0002\u029f\u02a0\u0005\u0169\u00b5\u0002',
-  '\u02a0\u02a1\u0005\u0151\u00a9\u0002\u02a1\u02a2\u0005\u0177\u00bc\u0002',
-  '\u02a2\u02a3\u0005\u0155\u00ab\u0002\u02a3\u02a4\u0005\u015f\u00b0\u0002',
-  '\u02a4\u00a0\u0003\u0002\u0002\u0002\u02a5\u02a6\u0005\u0179\u00bd\u0002',
-  '\u02a6\u02a7\u0005\u016b\u00b6\u0002\u02a7\u02a8\u0005\u017d\u00bf\u0002',
-  '\u02a8\u02a9\u0005\u0161\u00b1\u0002\u02a9\u02aa\u0005\u016b\u00b6\u0002',
-  '\u02aa\u02ab\u0005\u0157\u00ac\u0002\u02ab\u00a2\u0003\u0002\u0002\u0002',
-  '\u02ac\u02ad\u0005\u0169\u00b5\u0002\u02ad\u02ae\u0005\u0159\u00ad\u0002',
-  '\u02ae\u02af\u0005\u0173\u00ba\u0002\u02af\u02b0\u0005\u015d\u00af\u0002',
-  '\u02b0\u02b1\u0005\u0159\u00ad\u0002\u02b1\u00a4\u0003\u0002\u0002\u0002',
-  '\u02b2\u02b3\u0005\u0175\u00bb\u0002\u02b3\u02b4\u0005\u0159\u00ad\u0002',
-  '\u02b4\u02b5\u0005\u0177\u00bc\u0002\u02b5\u00a6\u0003\u0002\u0002\u0002',
-  '\u02b6\u02b7\u0005\u0157\u00ac\u0002\u02b7\u02b8\u0005\u0159\u00ad\u0002',
-  '\u02b8\u02b9\u0005\u0177\u00bc\u0002\u02b9\u02ba\u0005\u0151\u00a9\u0002',
-  '\u02ba\u02bb\u0005\u0155\u00ab\u0002\u02bb\u02bc\u0005\u015f\u00b0\u0002',
-  '\u02bc\u00a8\u0003\u0002\u0002\u0002\u02bd\u02be\u0005\u0157\u00ac\u0002',
-  '\u02be\u02bf\u0005\u0159\u00ad\u0002\u02bf\u02c0\u0005\u0167\u00b4\u0002',
-  '\u02c0\u02c1\u0005\u0159\u00ad\u0002\u02c1\u02c2\u0005\u0177\u00bc\u0002',
-  '\u02c2\u02c3\u0005\u0159\u00ad\u0002\u02c3\u00aa\u0003\u0002\u0002\u0002',
-  '\u02c4\u02c5\u0005\u0173\u00ba\u0002\u02c5\u02c6\u0005\u0159\u00ad\u0002',
-  '\u02c6\u02c7\u0005\u0169\u00b5\u0002\u02c7\u02c8\u0005\u016d\u00b7\u0002',
-  '\u02c8\u02c9\u0005\u017b\u00be\u0002\u02c9\u02ca\u0005\u0159\u00ad\u0002',
-  '\u02ca\u00ac\u0003\u0002\u0002\u0002\u02cb\u02cc\u0005\u015b\u00ae\u0002',
-  '\u02cc\u02cd\u0005\u016d\u00b7\u0002\u02cd\u02ce\u0005\u0173\u00ba\u0002',
-  '\u02ce\u02cf\u0005\u0159\u00ad\u0002\u02cf\u02d0\u0005\u0151\u00a9\u0002',
-  '\u02d0\u02d1\u0005\u0155\u00ab\u0002\u02d1\u02d2\u0005\u015f\u00b0\u0002',
-  '\u02d2\u00ae\u0003\u0002\u0002\u0002\u02d3\u02d4\u0005\u0161\u00b1\u0002',
-  '\u02d4\u02d5\u0005\u016b\u00b6\u0002\u02d5\u00b0\u0003\u0002\u0002\u0002',
-  '\u02d6\u02d7\u0005\u0157\u00ac\u0002\u02d7\u02d8\u0005\u0161\u00b1\u0002',
-  '\u02d8\u02d9\u0005\u0175\u00bb\u0002\u02d9\u02da\u0005\u0177\u00bc\u0002',
-  '\u02da\u02db\u0005\u0161\u00b1\u0002\u02db\u02dc\u0005\u016b\u00b6\u0002',
-  '\u02dc\u02dd\u0005\u0155\u00ab\u0002\u02dd\u02de\u0005\u0177\u00bc\u0002',
-  '\u02de\u00b2\u0003\u0002\u0002\u0002\u02df\u02e0\u0005\u0173\u00ba\u0002',
-  '\u02e0\u02e1\u0005\u0159\u00ad\u0002\u02e1\u02e2\u0005\u0177\u00bc\u0002',
-  '\u02e2\u02e3\u0005\u0179\u00bd\u0002\u02e3\u02e4\u0005\u0173\u00ba\u0002',
-  '\u02e4\u02e5\u0005\u016b\u00b6\u0002\u02e5\u00b4\u0003\u0002\u0002\u0002',
-  '\u02e6\u02e7\u0005\u016d\u00b7\u0002\u02e7\u02e8\u0005\u0173\u00ba\u0002',
-  '\u02e8\u02e9\u0005\u0157\u00ac\u0002\u02e9\u02ea\u0005\u0159\u00ad\u0002',
-  '\u02ea\u02eb\u0005\u0173\u00ba\u0002\u02eb\u00b6\u0003\u0002\u0002\u0002',
-  '\u02ec\u02ed\u0005\u0153\u00aa\u0002\u02ed\u02ee\u0005\u0181\u00c1\u0002',
-  '\u02ee\u00b8\u0003\u0002\u0002\u0002\u02ef\u02f0\u0005\u0175\u00bb\u0002',
-  '\u02f0\u02f1\u0005\u0165\u00b3\u0002\u02f1\u02f2\u0005\u0161\u00b1\u0002',
-  '\u02f2\u02f3\u0005\u016f\u00b8\u0002\u02f3\u00ba\u0003\u0002\u0002\u0002',
-  '\u02f4\u02f5\u0005\u0167\u00b4\u0002\u02f5\u02f6\u0005\u0161\u00b1\u0002',
-  '\u02f6\u02f7\u0005\u0169\u00b5\u0002\u02f7\u02f8\u0005\u0161\u00b1\u0002',
-  '\u02f8\u02f9\u0005\u0177\u00bc\u0002\u02f9\u00bc\u0003\u0002\u0002\u0002',
-  '\u02fa\u02fb\u0005\u0151\u00a9\u0002\u02fb\u02fc\u0005\u0175\u00bb\u0002',
-  '\u02fc\u02fd\u0005\u0155\u00ab\u0002\u02fd\u02fe\u0005\u0159\u00ad\u0002',
-  '\u02fe\u02ff\u0005\u016b\u00b6\u0002\u02ff\u0300\u0005\u0157\u00ac\u0002',
-  '\u0300\u0301\u0005\u0161\u00b1\u0002\u0301\u0302\u0005\u016b\u00b6\u0002',
-  '\u0302\u0303\u0005\u015d\u00af\u0002\u0303\u00be\u0003\u0002\u0002\u0002',
-  '\u0304\u0305\u0005\u0151\u00a9\u0002\u0305\u0306\u0005\u0175\u00bb\u0002',
-  '\u0306\u0307\u0005\u0155\u00ab\u0002\u0307\u00c0\u0003\u0002\u0002\u0002',
-  '\u0308\u0309\u0005\u0157\u00ac\u0002\u0309\u030a\u0005\u0159\u00ad\u0002',
-  '\u030a\u030b\u0005\u0175\u00bb\u0002\u030b\u030c\u0005\u0155\u00ab\u0002',
-  '\u030c\u030d\u0005\u0159\u00ad\u0002\u030d\u030e\u0005\u016b\u00b6\u0002',
-  '\u030e\u030f\u0005\u0157\u00ac\u0002\u030f\u0310\u0005\u0161\u00b1\u0002',
-  '\u0310\u0311\u0005\u016b\u00b6\u0002\u0311\u0312\u0005\u015d\u00af\u0002',
-  '\u0312\u00c2\u0003\u0002\u0002\u0002\u0313\u0314\u0005\u0157\u00ac\u0002',
-  '\u0314\u0315\u0005\u0159\u00ad\u0002\u0315\u0316\u0005\u0175\u00bb\u0002',
-  '\u0316\u0317\u0005\u0155\u00ab\u0002\u0317\u00c4\u0003\u0002\u0002\u0002',
-  '\u0318\u0319\u0005\u0163\u00b2\u0002\u0319\u031a\u0005\u016d\u00b7\u0002',
-  '\u031a\u031b\u0005\u0161\u00b1\u0002\u031b\u031c\u0005\u016b\u00b6\u0002',
-  '\u031c\u00c6\u0003\u0002\u0002\u0002\u031d\u031e\u0005\u0175\u00bb\u0002',
-  '\u031e\u031f\u0005\u0155\u00ab\u0002\u031f\u0320\u0005\u0151\u00a9\u0002',
-  '\u0320\u0321\u0005\u016b\u00b6\u0002\u0321\u00c8\u0003\u0002\u0002\u0002',
-  '\u0322\u0323\u0005\u0175\u00bb\u0002\u0323\u0324\u0005\u0177\u00bc\u0002',
-  '\u0324\u0325\u0005\u0151\u00a9\u0002\u0325\u0326\u0005\u0173\u00ba\u0002',
-  '\u0326\u0327\u0005\u0177\u00bc\u0002\u0327\u00ca\u0003\u0002\u0002\u0002',
-  '\u0328\u0329\u0005\u016b\u00b6\u0002\u0329\u032a\u0005\u016d\u00b7\u0002',
-  '\u032a\u032b\u0005\u0157\u00ac\u0002\u032b\u032c\u0005\u0159\u00ad\u0002',
-  '\u032c\u00cc\u0003\u0002\u0002\u0002\u032d\u032e\u0005\u0173\u00ba\u0002',
-  '\u032e\u032f\u0005\u0159\u00ad\u0002\u032f\u0330\u0005\u0167\u00b4\u0002',
-  '\u0330\u0331\u0005\u0151\u00a9\u0002\u0331\u0332\u0005\u0177\u00bc\u0002',
-  '\u0332\u0333\u0005\u0161\u00b1\u0002\u0333\u0334\u0005\u016d\u00b7\u0002',
-  '\u0334\u0335\u0005\u016b\u00b6\u0002\u0335\u0336\u0005\u0175\u00bb\u0002',
-  '\u0336\u0337\u0005\u015f\u00b0\u0002\u0337\u0338\u0005\u0161\u00b1\u0002',
-  '\u0338\u0339\u0005\u016f\u00b8\u0002\u0339\u00ce\u0003\u0002\u0002\u0002',
-  '\u033a\u033b\u0005\u0173\u00ba\u0002\u033b\u033c\u0005\u0159\u00ad\u0002',
-  '\u033c\u033d\u0005\u0167\u00b4\u0002\u033d\u00d0\u0003\u0002\u0002\u0002',
-  '\u033e\u033f\u0005\u017d\u00bf\u0002\u033f\u0340\u0005\u015f\u00b0\u0002',
-  '\u0340\u0341\u0005\u0159\u00ad\u0002\u0341\u0342\u0005\u0173\u00ba\u0002',
-  '\u0342\u0343\u0005\u0159\u00ad\u0002\u0343\u00d2\u0003\u0002\u0002\u0002',
-  '\u0344\u0345\u0005\u0175\u00bb\u0002\u0345\u0346\u0005\u015f\u00b0\u0002',
-  '\u0346\u0347\u0005\u016d\u00b7\u0002\u0347\u0348\u0005\u0173\u00ba\u0002',
-  '\u0348\u0349\u0005\u0177\u00bc\u0002\u0349\u034a\u0005\u0159\u00ad\u0002',
-  '\u034a\u034b\u0005\u0175\u00bb\u0002\u034b\u034c\u0005\u0177\u00bc\u0002',
-  '\u034c\u034d\u0005\u016f\u00b8\u0002\u034d\u034e\u0005\u0151\u00a9\u0002',
-  '\u034e\u034f\u0005\u0177\u00bc\u0002\u034f\u0350\u0005\u015f\u00b0\u0002',
-  '\u0350\u00d4\u0003\u0002\u0002\u0002\u0351\u0352\u0005\u0151\u00a9\u0002',
-  '\u0352\u0353\u0005\u0167\u00b4\u0002\u0353\u0354\u0005\u0167\u00b4\u0002',
-  '\u0354\u0355\u0005\u0175\u00bb\u0002\u0355\u0356\u0005\u015f\u00b0\u0002',
-  '\u0356\u0357\u0005\u016d\u00b7\u0002\u0357\u0358\u0005\u0173\u00ba\u0002',
-  '\u0358\u0359\u0005\u0177\u00bc\u0002\u0359\u035a\u0005\u0159\u00ad\u0002',
-  '\u035a\u035b\u0005\u0175\u00bb\u0002\u035b\u035c\u0005\u0177\u00bc\u0002',
-  '\u035c\u035d\u0005\u016f\u00b8\u0002\u035d\u035e\u0005\u0151\u00a9\u0002',
-  '\u035e\u035f\u0005\u0177\u00bc\u0002\u035f\u0360\u0005\u015f\u00b0\u0002',
-  '\u0360\u0361\u0005\u0175\u00bb\u0002\u0361\u00d6\u0003\u0002\u0002\u0002',
-  '\u0362\u0363\u0005\u016d\u00b7\u0002\u0363\u0364\u0005\u0173\u00ba\u0002',
-  '\u0364\u00d8\u0003\u0002\u0002\u0002\u0365\u0366\u0005\u017f\u00c0\u0002',
-  '\u0366\u0367\u0005\u016d\u00b7\u0002\u0367\u0368\u0005\u0173\u00ba\u0002',
-  '\u0368\u00da\u0003\u0002\u0002\u0002\u0369\u036a\u0005\u0151\u00a9\u0002',
-  '\u036a\u036b\u0005\u016b\u00b6\u0002\u036b\u036c\u0005\u0157\u00ac\u0002',
-  '\u036c\u00dc\u0003\u0002\u0002\u0002\u036d\u036e\u0005\u016b\u00b6\u0002',
-  '\u036e\u036f\u0005\u016d\u00b7\u0002\u036f\u0370\u0005\u0177\u00bc\u0002',
-  '\u0370\u00de\u0003\u0002\u0002\u0002\u0371\u0372\u0005\u0175\u00bb\u0002',
-  '\u0372\u0373\u0005\u0177\u00bc\u0002\u0373\u0374\u0005\u0151\u00a9\u0002',
-  '\u0374\u0375\u0005\u0173\u00ba\u0002\u0375\u0376\u0005\u0177\u00bc\u0002',
-  '\u0376\u0377\u0005\u0175\u00bb\u0002\u0377\u00e0\u0003\u0002\u0002\u0002',
-  '\u0378\u0379\u0005\u0159\u00ad\u0002\u0379\u037a\u0005\u016b\u00b6\u0002',
-  '\u037a\u037b\u0005\u0157\u00ac\u0002\u037b\u037c\u0005\u0175\u00bb\u0002',
-  '\u037c\u00e2\u0003\u0002\u0002\u0002\u037d\u037e\u0005\u0155\u00ab\u0002',
-  '\u037e\u037f\u0005\u016d\u00b7\u0002\u037f\u0380\u0005\u016b\u00b6\u0002',
-  '\u0380\u0381\u0005\u0177\u00bc\u0002\u0381\u0382\u0005\u0151\u00a9\u0002',
-  '\u0382\u0383\u0005\u0161\u00b1\u0002\u0383\u0384\u0005\u016b\u00b6\u0002',
-  '\u0384\u0385\u0005\u0175\u00bb\u0002\u0385\u00e4\u0003\u0002\u0002\u0002',
-  '\u0386\u0387\u0005\u016b\u00b6\u0002\u0387\u0388\u0005\u0179\u00bd\u0002',
-  '\u0388\u0389\u0005\u0167\u00b4\u0002\u0389\u038a\u0005\u0167\u00b4\u0002',
-  '\u038a\u00e6\u0003\u0002\u0002\u0002\u038b\u038c\u0005\u0155\u00ab\u0002',
-  '\u038c\u038d\u0005\u016d\u00b7\u0002\u038d\u038e\u0005\u0179\u00bd\u0002',
-  '\u038e\u038f\u0005\u016b\u00b6\u0002\u038f\u0390\u0005\u0177\u00bc\u0002',
-  '\u0390\u00e8\u0003\u0002\u0002\u0002\u0391\u0392\u0005\u015b\u00ae\u0002',
-  '\u0392\u0393\u0005\u0161\u00b1\u0002\u0393\u0394\u0005\u0167\u00b4\u0002',
-  '\u0394\u0395\u0005\u0177\u00bc\u0002\u0395\u0396\u0005\u0159\u00ad\u0002',
-  '\u0396\u0397\u0005\u0173\u00ba\u0002\u0397\u00ea\u0003\u0002\u0002\u0002',
-  '\u0398\u0399\u0005\u0159\u00ad\u0002\u0399\u039a\u0005\u017f\u00c0\u0002',
-  '\u039a\u039b\u0005\u0177\u00bc\u0002\u039b\u039c\u0005\u0173\u00ba\u0002',
-  '\u039c\u039d\u0005\u0151\u00a9\u0002\u039d\u039e\u0005\u0155\u00ab\u0002',
-  '\u039e\u039f\u0005\u0177\u00bc\u0002\u039f\u00ec\u0003\u0002\u0002\u0002',
-  '\u03a0\u03a1\u0005\u0151\u00a9\u0002\u03a1\u03a2\u0005\u016b\u00b6\u0002',
-  '\u03a2\u03a3\u0005\u0181\u00c1\u0002\u03a3\u00ee\u0003\u0002\u0002\u0002',
-  '\u03a4\u03a5\u0005\u016b\u00b6\u0002\u03a5\u03a6\u0005\u016d\u00b7\u0002',
-  '\u03a6\u03a7\u0005\u016b\u00b6\u0002\u03a7\u03a8\u0005\u0159\u00ad\u0002',
-  '\u03a8\u00f0\u0003\u0002\u0002\u0002\u03a9\u03aa\u0005\u0175\u00bb\u0002',
-  '\u03aa\u03ab\u0005\u0161\u00b1\u0002\u03ab\u03ac\u0005\u016b\u00b6\u0002',
-  '\u03ac\u03ad\u0005\u015d\u00af\u0002\u03ad\u03ae\u0005\u0167\u00b4\u0002',
-  '\u03ae\u03af\u0005\u0159\u00ad\u0002\u03af\u00f2\u0003\u0002\u0002\u0002',
-  '\u03b0\u03b1\u0005\u0177\u00bc\u0002\u03b1\u03b2\u0005\u0173\u00ba\u0002',
-  '\u03b2\u03b3\u0005\u0179\u00bd\u0002\u03b3\u03b4\u0005\u0159\u00ad\u0002',
-  '\u03b4\u00f4\u0003\u0002\u0002\u0002\u03b5\u03b6\u0005\u015b\u00ae\u0002',
-  '\u03b6\u03b7\u0005\u0151\u00a9\u0002\u03b7\u03b8\u0005\u0167\u00b4\u0002',
-  '\u03b8\u03b9\u0005\u0175\u00bb\u0002\u03b9\u03ba\u0005\u0159\u00ad\u0002',
-  '\u03ba\u00f6\u0003\u0002\u0002\u0002\u03bb\u03bc\u0005\u0173\u00ba\u0002',
-  '\u03bc\u03bd\u0005\u0159\u00ad\u0002\u03bd\u03be\u0005\u0157\u00ac\u0002',
-  '\u03be\u03bf\u0005\u0179\u00bd\u0002\u03bf\u03c0\u0005\u0155\u00ab\u0002',
-  '\u03c0\u03c1\u0005\u0159\u00ad\u0002\u03c1\u00f8\u0003\u0002\u0002\u0002',
-  '\u03c2\u03c3\u0005\u0155\u00ab\u0002\u03c3\u03c4\u0005\u0151\u00a9\u0002',
-  '\u03c4\u03c5\u0005\u0175\u00bb\u0002\u03c5\u03c6\u0005\u0159\u00ad\u0002',
-  '\u03c6\u00fa\u0003\u0002\u0002\u0002\u03c7\u03c8\u0005\u0159\u00ad\u0002',
-  '\u03c8\u03c9\u0005\u0167\u00b4\u0002\u03c9\u03ca\u0005\u0175\u00bb\u0002',
-  '\u03ca\u03cb\u0005\u0159\u00ad\u0002\u03cb\u00fc\u0003\u0002\u0002\u0002',
-  '\u03cc\u03cd\u0005\u0159\u00ad\u0002\u03cd\u03ce\u0005\u016b\u00b6\u0002',
-  '\u03ce\u03cf\u0005\u0157\u00ac\u0002\u03cf\u00fe\u0003\u0002\u0002\u0002',
-  '\u03d0\u03d1\u0005\u017d\u00bf\u0002\u03d1\u03d2\u0005\u015f\u00b0\u0002',
-  '\u03d2\u03d3\u0005\u0159\u00ad\u0002\u03d3\u03d4\u0005\u016b\u00b6\u0002',
-  '\u03d4\u0100\u0003\u0002\u0002\u0002\u03d5\u03d6\u0005\u0177\u00bc\u0002',
-  '\u03d6\u03d7\u0005\u015f\u00b0\u0002\u03d7\u03d8\u0005\u0159\u00ad\u0002',
-  '\u03d8\u03d9\u0005\u016b\u00b6\u0002\u03d9\u0102\u0003\u0002\u0002\u0002',
-  '\u03da\u03db\u0005\u0155\u00ab\u0002\u03db\u03dc\u0005\u0151\u00a9\u0002',
-  '\u03dc\u03dd\u0005\u0167\u00b4\u0002\u03dd\u03de\u0005\u0167\u00b4\u0002',
-  '\u03de\u0104\u0003\u0002\u0002\u0002\u03df\u03e0\u0005\u0181\u00c1\u0002',
-  '\u03e0\u03e1\u0005\u0161\u00b1\u0002\u03e1\u03e2\u0005\u0159\u00ad\u0002',
-  '\u03e2\u03e3\u0005\u0167\u00b4\u0002\u03e3\u03e4\u0005\u0157\u00ac\u0002',
-  '\u03e4\u0106\u0003\u0002\u0002\u0002\u03e5\u03e6\u0005\u0165\u00b3\u0002',
-  '\u03e6\u03e7\u0005\u0159\u00ad\u0002\u03e7\u03e8\u0005\u0181\u00c1\u0002',
-  '\u03e8\u0108\u0003\u0002\u0002\u0002\u03e9\u03f2\u0007$\u0002\u0002',
-  '\u03ea\u03f1\n\u0002\u0002\u0002\u03eb\u03ee\u0007^\u0002\u0002\u03ec',
-  '\u03ef\u000b\u0002\u0002\u0002\u03ed\u03ef\u0007\u0002\u0002\u0003\u03ee',
-  '\u03ec\u0003\u0002\u0002\u0002\u03ee\u03ed\u0003\u0002\u0002\u0002\u03ef',
-  '\u03f1\u0003\u0002\u0002\u0002\u03f0\u03ea\u0003\u0002\u0002\u0002\u03f0',
-  '\u03eb\u0003\u0002\u0002\u0002\u03f1\u03f4\u0003\u0002\u0002\u0002\u03f2',
-  '\u03f0\u0003\u0002\u0002\u0002\u03f2\u03f3\u0003\u0002\u0002\u0002\u03f3',
-  '\u03f5\u0003\u0002\u0002\u0002\u03f4\u03f2\u0003\u0002\u0002\u0002\u03f5',
-  '\u0404\u0007$\u0002\u0002\u03f6\u03ff\u0007)\u0002\u0002\u03f7\u03fe',
-  '\n\u0003\u0002\u0002\u03f8\u03fb\u0007^\u0002\u0002\u03f9\u03fc\u000b',
-  '\u0002\u0002\u0002\u03fa\u03fc\u0007\u0002\u0002\u0003\u03fb\u03f9\u0003',
-  '\u0002\u0002\u0002\u03fb\u03fa\u0003\u0002\u0002\u0002\u03fc\u03fe\u0003',
-  '\u0002\u0002\u0002\u03fd\u03f7\u0003\u0002\u0002\u0002\u03fd\u03f8\u0003',
-  '\u0002\u0002\u0002\u03fe\u0401\u0003\u0002\u0002\u0002\u03ff\u03fd\u0003',
-  '\u0002\u0002\u0002\u03ff\u0400\u0003\u0002\u0002\u0002\u0400\u0402\u0003',
-  '\u0002\u0002\u0002\u0401\u03ff\u0003\u0002\u0002\u0002\u0402\u0404\u0007',
-  ')\u0002\u0002\u0403\u03e9\u0003\u0002\u0002\u0002\u0403\u03f6\u0003',
-  '\u0002\u0002\u0002\u0404\u010a\u0003\u0002\u0002\u0002\u0405\u0406\u0007',
-  "'\u0002\u0002\u0406\u0407\t\u0004\u0002\u0002\u0407\u0409\t\u0004\u0002",
-  '\u0002\u0408\u0405\u0003\u0002\u0002\u0002\u0409\u040a\u0003\u0002\u0002',
-  '\u0002\u040a\u0408\u0003\u0002\u0002\u0002\u040a\u040b\u0003\u0002\u0002',
-  '\u0002\u040b\u010c\u0003\u0002\u0002\u0002\u040c\u041e\u0007^\u0002',
-  '\u0002\u040d\u041f\t\u0005\u0002\u0002\u040e\u040f\t\u0006\u0002\u0002',
-  '\u040f\u0410\u0005\u0117\u008c\u0002\u0410\u0411\u0005\u0117\u008c\u0002',
-  '\u0411\u0412\u0005\u0117\u008c\u0002\u0412\u0413\u0005\u0117\u008c\u0002',
-  '\u0413\u041f\u0003\u0002\u0002\u0002\u0414\u0415\t\u0006\u0002\u0002',
-  '\u0415\u0416\u0005\u0117\u008c\u0002\u0416\u0417\u0005\u0117\u008c\u0002',
-  '\u0417\u0418\u0005\u0117\u008c\u0002\u0418\u0419\u0005\u0117\u008c\u0002',
-  '\u0419\u041a\u0005\u0117\u008c\u0002\u041a\u041b\u0005\u0117\u008c\u0002',
-  '\u041b\u041c\u0005\u0117\u008c\u0002\u041c\u041d\u0005\u0117\u008c\u0002',
-  '\u041d\u041f\u0003\u0002\u0002\u0002\u041e\u040d\u0003\u0002\u0002\u0002',
-  '\u041e\u040e\u0003\u0002\u0002\u0002\u041e\u0414\u0003\u0002\u0002\u0002',
-  '\u041f\u010e\u0003\u0002\u0002\u0002\u0420\u0421\u00072\u0002\u0002',
-  '\u0421\u0422\u0007z\u0002\u0002\u0422\u0424\u0003\u0002\u0002\u0002',
-  '\u0423\u0425\u0005\u0117\u008c\u0002\u0424\u0423\u0003\u0002\u0002\u0002',
-  '\u0425\u0426\u0003\u0002\u0002\u0002\u0426\u0424\u0003\u0002\u0002\u0002',
-  '\u0426\u0427\u0003\u0002\u0002\u0002\u0427\u0110\u0003\u0002\u0002\u0002',
-  '\u0428\u0431\u0005\u0121\u0091\u0002\u0429\u042d\u0005\u011b\u008e\u0002',
-  '\u042a\u042c\u0005\u0119\u008d\u0002\u042b\u042a\u0003\u0002\u0002\u0002',
-  '\u042c\u042f\u0003\u0002\u0002\u0002\u042d\u042b\u0003\u0002\u0002\u0002',
-  '\u042d\u042e\u0003\u0002\u0002\u0002\u042e\u0431\u0003\u0002\u0002\u0002',
-  '\u042f\u042d\u0003\u0002\u0002\u0002\u0430\u0428\u0003\u0002\u0002\u0002',
-  '\u0430\u0429\u0003\u0002\u0002\u0002\u0431\u0112\u0003\u0002\u0002\u0002',
-  '\u0432\u0434\u0005\u0121\u0091\u0002\u0433\u0435\u0005\u011f\u0090\u0002',
-  '\u0434\u0433\u0003\u0002\u0002\u0002\u0435\u0436\u0003\u0002\u0002\u0002',
-  '\u0436\u0434\u0003\u0002\u0002\u0002\u0436\u0437\u0003\u0002\u0002\u0002',
-  '\u0437\u0114\u0003\u0002\u0002\u0002\u0438\u043a\t\u0007\u0002\u0002',
-  '\u0439\u0438\u0003\u0002\u0002\u0002\u043a\u0116\u0003\u0002\u0002\u0002',
-  '\u043b\u043e\u0005\u0119\u008d\u0002\u043c\u043e\u0005\u0115\u008b\u0002',
-  '\u043d\u043b\u0003\u0002\u0002\u0002\u043d\u043c\u0003\u0002\u0002\u0002',
-  '\u043e\u0118\u0003\u0002\u0002\u0002\u043f\u0442\u0005\u0121\u0091\u0002',
-  '\u0440\u0442\u0005\u011b\u008e\u0002\u0441\u043f\u0003\u0002\u0002\u0002',
-  '\u0441\u0440\u0003\u0002\u0002\u0002\u0442\u011a\u0003\u0002\u0002\u0002',
-  '\u0443\u0446\u0005\u011d\u008f\u0002\u0444\u0446\u0004:;\u0002\u0445',
-  '\u0443\u0003\u0002\u0002\u0002\u0445\u0444\u0003\u0002\u0002\u0002\u0446',
-  '\u011c\u0003\u0002\u0002\u0002\u0447\u0448\u000439\u0002\u0448\u011e',
-  '\u0003\u0002\u0002\u0002\u0449\u044c\u0005\u0121\u0091\u0002\u044a\u044c',
-  '\u0005\u011d\u008f\u0002\u044b\u0449\u0003\u0002\u0002\u0002\u044b\u044a',
-  '\u0003\u0002\u0002\u0002\u044c\u0120\u0003\u0002\u0002\u0002\u044d\u044e',
-  '\u00072\u0002\u0002\u044e\u0122\u0003\u0002\u0002\u0002\u044f\u0451',
-  '\u0005\u0119\u008d\u0002\u0450\u044f\u0003\u0002\u0002\u0002\u0451\u0452',
-  '\u0003\u0002\u0002\u0002\u0452\u0450\u0003\u0002\u0002\u0002\u0452\u0453',
-  '\u0003\u0002\u0002\u0002\u0453\u0466\u0003\u0002\u0002\u0002\u0454\u0456',
-  '\u0005\u0119\u008d\u0002\u0455\u0454\u0003\u0002\u0002\u0002\u0456\u0457',
-  '\u0003\u0002\u0002\u0002\u0457\u0455\u0003\u0002\u0002\u0002\u0457\u0458',
-  '\u0003\u0002\u0002\u0002\u0458\u0459\u0003\u0002\u0002\u0002\u0459\u045b',
-  '\u00070\u0002\u0002\u045a\u045c\u0005\u0119\u008d\u0002\u045b\u045a',
-  '\u0003\u0002\u0002\u0002\u045c\u045d\u0003\u0002\u0002\u0002\u045d\u045b',
-  '\u0003\u0002\u0002\u0002\u045d\u045e\u0003\u0002\u0002\u0002\u045e\u0466',
-  '\u0003\u0002\u0002\u0002\u045f\u0461\u00070\u0002\u0002\u0460\u0462',
-  '\u0005\u0119\u008d\u0002\u0461\u0460\u0003\u0002\u0002\u0002\u0462\u0463',
-  '\u0003\u0002\u0002\u0002\u0463\u0461\u0003\u0002\u0002\u0002\u0463\u0464',
-  '\u0003\u0002\u0002\u0002\u0464\u0466\u0003\u0002\u0002\u0002\u0465\u0450',
-  '\u0003\u0002\u0002\u0002\u0465\u0455\u0003\u0002\u0002\u0002\u0465\u045f',
-  '\u0003\u0002\u0002\u0002\u0466\u0467\u0003\u0002\u0002\u0002\u0467\u0469',
-  '\t\b\u0002\u0002\u0468\u046a\u0007/\u0002\u0002\u0469\u0468\u0003\u0002',
-  '\u0002\u0002\u0469\u046a\u0003\u0002\u0002\u0002\u046a\u046c\u0003\u0002',
-  '\u0002\u0002\u046b\u046d\u0005\u0119\u008d\u0002\u046c\u046b\u0003\u0002',
-  '\u0002\u0002\u046d\u046e\u0003\u0002\u0002\u0002\u046e\u046c\u0003\u0002',
-  '\u0002\u0002\u046e\u046f\u0003\u0002\u0002\u0002\u046f\u0124\u0003\u0002',
-  '\u0002\u0002\u0470\u0472\u0005\u0119\u008d\u0002\u0471\u0470\u0003\u0002',
-  '\u0002\u0002\u0472\u0475\u0003\u0002\u0002\u0002\u0473\u0471\u0003\u0002',
-  '\u0002\u0002\u0473\u0474\u0003\u0002\u0002\u0002\u0474\u0476\u0003\u0002',
-  '\u0002\u0002\u0475\u0473\u0003\u0002\u0002\u0002\u0476\u0478\u00070',
-  '\u0002\u0002\u0477\u0479\u0005\u0119\u008d\u0002\u0478\u0477\u0003\u0002',
-  '\u0002\u0002\u0479\u047a\u0003\u0002\u0002\u0002\u047a\u0478\u0003\u0002',
-  '\u0002\u0002\u047a\u047b\u0003\u0002\u0002\u0002\u047b\u0126\u0003\u0002',
-  '\u0002\u0002\u047c\u0480\u0005\u0129\u0095\u0002\u047d\u047f\u0005\u012b',
-  '\u0096\u0002\u047e\u047d\u0003\u0002\u0002\u0002\u047f\u0482\u0003\u0002',
-  '\u0002\u0002\u0480\u047e\u0003\u0002\u0002\u0002\u0480\u0481\u0003\u0002',
-  '\u0002\u0002\u0481\u0128\u0003\u0002\u0002\u0002\u0482\u0480\u0003\u0002',
-  '\u0002\u0002\u0483\u0486\u0005\u014f\u00a8\u0002\u0484\u0486\t\t\u0002',
-  '\u0002\u0485\u0483\u0003\u0002\u0002\u0002\u0485\u0484\u0003\u0002\u0002',
-  '\u0002\u0486\u012a\u0003\u0002\u0002\u0002\u0487\u048a\u0005\u013b\u009e',
-  '\u0002\u0488\u048a\u0005\u0143\u00a2\u0002\u0489\u0487\u0003\u0002\u0002',
-  '\u0002\u0489\u0488\u0003\u0002\u0002\u0002\u048a\u012c\u0003\u0002\u0002',
-  '\u0002\u048b\u0491\u0007b\u0002\u0002\u048c\u0490\n\n\u0002\u0002\u048d',
-  '\u048e\u0007b\u0002\u0002\u048e\u0490\u0007b\u0002\u0002\u048f\u048c',
-  '\u0003\u0002\u0002\u0002\u048f\u048d\u0003\u0002\u0002\u0002\u0490\u0493',
-  '\u0003\u0002\u0002\u0002\u0491\u048f\u0003\u0002\u0002\u0002\u0491\u0492',
-  '\u0003\u0002\u0002\u0002\u0492\u0494\u0003\u0002\u0002\u0002\u0493\u0491',
-  '\u0003\u0002\u0002\u0002\u0494\u0495\u0007b\u0002\u0002\u0495\u012e',
-  '\u0003\u0002\u0002\u0002\u0496\u0498\u0005\u0131\u0099\u0002\u0497\u0496',
-  '\u0003\u0002\u0002\u0002\u0498\u0499\u0003\u0002\u0002\u0002\u0499\u0497',
-  '\u0003\u0002\u0002\u0002\u0499\u049a\u0003\u0002\u0002\u0002\u049a\u0130',
-  '\u0003\u0002\u0002\u0002\u049b\u04a8\u0005\u0145\u00a3\u0002\u049c\u04a8',
-  '\u0005\u0147\u00a4\u0002\u049d\u04a8\u0005\u0149\u00a5\u0002\u049e\u04a8',
-  '\u0005\u014b\u00a6\u0002\u049f\u04a8\u0005\u0137\u009c\u0002\u04a0\u04a8',
-  '\u0005\u0141\u00a1\u0002\u04a1\u04a8\u0005\u013f\u00a0\u0002\u04a2\u04a8',
-  '\u0005\u013d\u009f\u0002\u04a3\u04a8\u0005\u0139\u009d\u0002\u04a4\u04a8',
-  '\u0005\u014d\u00a7\u0002\u04a5\u04a8\t\u000b\u0002\u0002\u04a6\u04a8',
-  '\u0005\u0133\u009a\u0002\u04a7\u049b\u0003\u0002\u0002\u0002\u04a7\u049c',
-  '\u0003\u0002\u0002\u0002\u04a7\u049d\u0003\u0002\u0002\u0002\u04a7\u049e',
-  '\u0003\u0002\u0002\u0002\u04a7\u049f\u0003\u0002\u0002\u0002\u04a7\u04a0',
-  '\u0003\u0002\u0002\u0002\u04a7\u04a1\u0003\u0002\u0002\u0002\u04a7\u04a2',
-  '\u0003\u0002\u0002\u0002\u04a7\u04a3\u0003\u0002\u0002\u0002\u04a7\u04a4',
-  '\u0003\u0002\u0002\u0002\u04a7\u04a5\u0003\u0002\u0002\u0002\u04a7\u04a6',
-  '\u0003\u0002\u0002\u0002\u04a8\u0132\u0003\u0002\u0002\u0002\u04a9\u04aa',
-  '\u00071\u0002\u0002\u04aa\u04ab\u0007,\u0002\u0002\u04ab\u04af\u0003',
-  '\u0002\u0002\u0002\u04ac\u04ae\u000b\u0002\u0002\u0002\u04ad\u04ac\u0003',
-  '\u0002\u0002\u0002\u04ae\u04b1\u0003\u0002\u0002\u0002\u04af\u04b0\u0003',
-  '\u0002\u0002\u0002\u04af\u04ad\u0003\u0002\u0002\u0002\u04b0\u04b2\u0003',
-  '\u0002\u0002\u0002\u04b1\u04af\u0003\u0002\u0002\u0002\u04b2\u04b3\u0007',
-  ',\u0002\u0002\u04b3\u04be\u00071\u0002\u0002\u04b4\u04b5\u00071\u0002',
-  '\u0002\u04b5\u04b6\u00071\u0002\u0002\u04b6\u04ba\u0003\u0002\u0002',
-  '\u0002\u04b7\u04b9\n\f\u0002\u0002\u04b8\u04b7\u0003\u0002\u0002\u0002',
-  '\u04b9\u04bc\u0003\u0002\u0002\u0002\u04ba\u04b8\u0003\u0002\u0002\u0002',
-  '\u04ba\u04bb\u0003\u0002\u0002\u0002\u04bb\u04be\u0003\u0002\u0002\u0002',
-  '\u04bc\u04ba\u0003\u0002\u0002\u0002\u04bd\u04a9\u0003\u0002\u0002\u0002',
-  '\u04bd\u04b4\u0003\u0002\u0002\u0002\u04be\u0134\u0003\u0002\u0002\u0002',
-  '\u04bf\u04c0\u000b\u0002\u0002\u0002\u04c0\u0136\u0003\u0002\u0002\u0002',
-  '\u04c1\u04c2\t\r\u0002\u0002\u04c2\u0138\u0003\u0002\u0002\u0002\u04c3',
-  '\u04c4\t\u000e\u0002\u0002\u04c4\u013a\u0003\u0002\u0002\u0002\u04c5',
-  '\u04c6\t\u000f\u0002\u0002\u04c6\u013c\u0003\u0002\u0002\u0002\u04c7',
-  '\u04c8\t\u0010\u0002\u0002\u04c8\u013e\u0003\u0002\u0002\u0002\u04c9',
-  '\u04ca\t\u0011\u0002\u0002\u04ca\u0140\u0003\u0002\u0002\u0002\u04cb',
-  '\u04cc\t\u0012\u0002\u0002\u04cc\u0142\u0003\u0002\u0002\u0002\u04cd',
-  '\u04ce\t\u0013\u0002\u0002\u04ce\u0144\u0003\u0002\u0002\u0002\u04cf',
-  '\u04d0\t\u0014\u0002\u0002\u04d0\u0146\u0003\u0002\u0002\u0002\u04d1',
-  '\u04d2\t\u0015\u0002\u0002\u04d2\u0148\u0003\u0002\u0002\u0002\u04d3',
-  '\u04d4\t\u0016\u0002\u0002\u04d4\u014a\u0003\u0002\u0002\u0002\u04d5',
-  '\u04d6\t\u0017\u0002\u0002\u04d6\u014c\u0003\u0002\u0002\u0002\u04d7',
-  '\u04d8\t\u0018\u0002\u0002\u04d8\u014e\u0003\u0002\u0002\u0002\u04d9',
-  '\u04da\t\u0019\u0002\u0002\u04da\u0150\u0003\u0002\u0002\u0002\u04db',
-  '\u04dc\t\u001a\u0002\u0002\u04dc\u0152\u0003\u0002\u0002\u0002\u04dd',
-  '\u04de\t\u001b\u0002\u0002\u04de\u0154\u0003\u0002\u0002\u0002\u04df',
-  '\u04e0\t\u001c\u0002\u0002\u04e0\u0156\u0003\u0002\u0002\u0002\u04e1',
-  '\u04e2\t\u001d\u0002\u0002\u04e2\u0158\u0003\u0002\u0002\u0002\u04e3',
-  '\u04e4\t\b\u0002\u0002\u04e4\u015a\u0003\u0002\u0002\u0002\u04e5\u04e6',
-  '\t\u001e\u0002\u0002\u04e6\u015c\u0003\u0002\u0002\u0002\u04e7\u04e8',
-  '\t\u001f\u0002\u0002\u04e8\u015e\u0003\u0002\u0002\u0002\u04e9\u04ea',
-  '\t \u0002\u0002\u04ea\u0160\u0003\u0002\u0002\u0002\u04eb\u04ec\t!\u0002',
-  '\u0002\u04ec\u0162\u0003\u0002\u0002\u0002\u04ed\u04ee\t"\u0002\u0002',
-  '\u04ee\u0164\u0003\u0002\u0002\u0002\u04ef\u04f0\t#\u0002\u0002\u04f0',
-  '\u0166\u0003\u0002\u0002\u0002\u04f1\u04f2\t$\u0002\u0002\u04f2\u0168',
-  '\u0003\u0002\u0002\u0002\u04f3\u04f4\t%\u0002\u0002\u04f4\u016a\u0003',
-  '\u0002\u0002\u0002\u04f5\u04f6\t&\u0002\u0002\u04f6\u016c\u0003\u0002',
-  "\u0002\u0002\u04f7\u04f8\t'\u0002\u0002\u04f8\u016e\u0003\u0002\u0002",
-  '\u0002\u04f9\u04fa\t(\u0002\u0002\u04fa\u0170\u0003\u0002\u0002\u0002',
-  '\u04fb\u04fc\t)\u0002\u0002\u04fc\u0172\u0003\u0002\u0002\u0002\u04fd',
-  '\u04fe\t*\u0002\u0002\u04fe\u0174\u0003\u0002\u0002\u0002\u04ff\u0500',
-  '\t+\u0002\u0002\u0500\u0176\u0003\u0002\u0002\u0002\u0501\u0502\t,\u0002',
-  '\u0002\u0502\u0178\u0003\u0002\u0002\u0002\u0503\u0504\t\u0006\u0002',
-  '\u0002\u0504\u017a\u0003\u0002\u0002\u0002\u0505\u0506\t-\u0002\u0002',
-  '\u0506\u017c\u0003\u0002\u0002\u0002\u0507\u0508\t.\u0002\u0002\u0508',
-  '\u017e\u0003\u0002\u0002\u0002\u0509\u050a\t/\u0002\u0002\u050a\u0180',
-  '\u0003\u0002\u0002\u0002\u050b\u050c\t0\u0002\u0002\u050c\u0182\u0003',
-  '\u0002\u0002\u0002\u050d\u050e\t1\u0002\u0002\u050e\u0184\u0003\u0002',
-  '\u0002\u0002(\u0002\u03ee\u03f0\u03f2\u03fb\u03fd\u03ff\u0403\u040a',
-  '\u041e\u0426\u042d\u0430\u0436\u0439\u043d\u0441\u0445\u044b\u0452\u0457',
-  '\u045d\u0463\u0465\u0469\u046e\u0473\u047a\u0480\u0485\u0489\u048f\u0491',
-  '\u0499\u04a7\u04af\u04ba\u04bd\u0002'
-].join('')
-
-var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN)
-
-var decisionsToDFA = atn.decisionToState.map(function(ds, index) {
-  return new antlr4.dfa.DFA(ds, index)
-})
-
-function CypherLexer(input) {
-  antlr4.Lexer.call(this, input)
-  this._interp = new antlr4.atn.LexerATNSimulator(
-    this,
-    atn,
-    decisionsToDFA,
-    new antlr4.PredictionContextCache()
-  )
-  return this
-}
-
-CypherLexer.prototype = Object.create(antlr4.Lexer.prototype)
-CypherLexer.prototype.constructor = CypherLexer
-
-CypherLexer.EOF = antlr4.Token.EOF
-CypherLexer.T__0 = 1
-CypherLexer.T__1 = 2
-CypherLexer.T__2 = 3
-CypherLexer.T__3 = 4
-CypherLexer.T__4 = 5
-CypherLexer.T__5 = 6
-CypherLexer.T__6 = 7
-CypherLexer.T__7 = 8
-CypherLexer.T__8 = 9
-CypherLexer.T__9 = 10
-CypherLexer.T__10 = 11
-CypherLexer.T__11 = 12
-CypherLexer.T__12 = 13
-CypherLexer.T__13 = 14
-CypherLexer.T__14 = 15
-CypherLexer.T__15 = 16
-CypherLexer.T__16 = 17
-CypherLexer.T__17 = 18
-CypherLexer.T__18 = 19
-CypherLexer.T__19 = 20
-CypherLexer.T__20 = 21
-CypherLexer.T__21 = 22
-CypherLexer.T__22 = 23
-CypherLexer.T__23 = 24
-CypherLexer.T__24 = 25
-CypherLexer.T__25 = 26
-CypherLexer.T__26 = 27
-CypherLexer.T__27 = 28
-CypherLexer.T__28 = 29
-CypherLexer.T__29 = 30
-CypherLexer.T__30 = 31
-CypherLexer.T__31 = 32
-CypherLexer.T__32 = 33
-CypherLexer.T__33 = 34
-CypherLexer.T__34 = 35
-CypherLexer.T__35 = 36
-CypherLexer.T__36 = 37
-CypherLexer.T__37 = 38
-CypherLexer.T__38 = 39
-CypherLexer.T__39 = 40
-CypherLexer.T__40 = 41
-CypherLexer.T__41 = 42
-CypherLexer.T__42 = 43
-CypherLexer.T__43 = 44
-CypherLexer.T__44 = 45
-CypherLexer.T__45 = 46
-CypherLexer.T__46 = 47
-CypherLexer.T__47 = 48
-CypherLexer.T__48 = 49
-CypherLexer.T__49 = 50
-CypherLexer.T__50 = 51
-CypherLexer.T__51 = 52
-CypherLexer.T__52 = 53
-CypherLexer.CYPHER = 54
-CypherLexer.EXPLAIN = 55
-CypherLexer.PROFILE = 56
-CypherLexer.USING = 57
-CypherLexer.PERIODIC = 58
-CypherLexer.COMMIT = 59
-CypherLexer.UNION = 60
-CypherLexer.ALL = 61
-CypherLexer.CREATE = 62
-CypherLexer.DROP = 63
-CypherLexer.INDEX = 64
-CypherLexer.ON = 65
-CypherLexer.CONSTRAINT = 66
-CypherLexer.ASSERT = 67
-CypherLexer.IS = 68
-CypherLexer.UNIQUE = 69
-CypherLexer.EXISTS = 70
-CypherLexer.LOAD = 71
-CypherLexer.CSV = 72
-CypherLexer.WITH = 73
-CypherLexer.HEADERS = 74
-CypherLexer.FROM = 75
-CypherLexer.AS = 76
-CypherLexer.FIELDTERMINATOR = 77
-CypherLexer.OPTIONAL = 78
-CypherLexer.MATCH = 79
-CypherLexer.UNWIND = 80
-CypherLexer.MERGE = 81
-CypherLexer.SET = 82
-CypherLexer.DETACH = 83
-CypherLexer.DELETE = 84
-CypherLexer.REMOVE = 85
-CypherLexer.FOREACH = 86
-CypherLexer.IN = 87
-CypherLexer.DISTINCT = 88
-CypherLexer.RETURN = 89
-CypherLexer.ORDER = 90
-CypherLexer.BY = 91
-CypherLexer.L_SKIP = 92
-CypherLexer.LIMIT = 93
-CypherLexer.ASCENDING = 94
-CypherLexer.ASC = 95
-CypherLexer.DESCENDING = 96
-CypherLexer.DESC = 97
-CypherLexer.JOIN = 98
-CypherLexer.SCAN = 99
-CypherLexer.START = 100
-CypherLexer.NODE = 101
-CypherLexer.RELATIONSHIP = 102
-CypherLexer.REL = 103
-CypherLexer.WHERE = 104
-CypherLexer.SHORTESTPATH = 105
-CypherLexer.ALLSHORTESTPATHS = 106
-CypherLexer.OR = 107
-CypherLexer.XOR = 108
-CypherLexer.AND = 109
-CypherLexer.NOT = 110
-CypherLexer.STARTS = 111
-CypherLexer.ENDS = 112
-CypherLexer.CONTAINS = 113
-CypherLexer.NULL = 114
-CypherLexer.COUNT = 115
-CypherLexer.FILTER = 116
-CypherLexer.EXTRACT = 117
-CypherLexer.ANY = 118
-CypherLexer.NONE = 119
-CypherLexer.SINGLE = 120
-CypherLexer.TRUE = 121
-CypherLexer.FALSE = 122
-CypherLexer.REDUCE = 123
-CypherLexer.CASE = 124
-CypherLexer.ELSE = 125
-CypherLexer.END = 126
-CypherLexer.WHEN = 127
-CypherLexer.THEN = 128
-CypherLexer.CALL = 129
-CypherLexer.YIELD = 130
-CypherLexer.KEY = 131
-CypherLexer.StringLiteral = 132
-CypherLexer.UrlHex = 133
-CypherLexer.EscapedChar = 134
-CypherLexer.HexInteger = 135
-CypherLexer.DecimalInteger = 136
-CypherLexer.OctalInteger = 137
-CypherLexer.HexLetter = 138
-CypherLexer.HexDigit = 139
-CypherLexer.Digit = 140
-CypherLexer.NonZeroDigit = 141
-CypherLexer.NonZeroOctDigit = 142
-CypherLexer.OctDigit = 143
-CypherLexer.ZeroDigit = 144
-CypherLexer.ExponentDecimalReal = 145
-CypherLexer.RegularDecimalReal = 146
-CypherLexer.UnescapedSymbolicName = 147
-CypherLexer.IdentifierStart = 148
-CypherLexer.IdentifierPart = 149
-CypherLexer.EscapedSymbolicName = 150
-CypherLexer.SP = 151
-CypherLexer.WHITESPACE = 152
-CypherLexer.Comment = 153
-CypherLexer.ERROR_TOKEN = 154
-
-CypherLexer.prototype.channelNames = ['DEFAULT_TOKEN_CHANNEL', 'HIDDEN']
-
-CypherLexer.prototype.modeNames = ['DEFAULT_MODE']
-
-CypherLexer.prototype.literalNames = [
-  null,
-  "';'",
-  "':'",
-  "'-'",
-  "'=>'",
-  "'://'",
-  "'/'",
-  "'.'",
-  "'@'",
-  "'#'",
-  "'?'",
-  "'&'",
-  "'='",
-  "'+'",
-  "'{'",
-  "','",
-  "'}'",
-  "'['",
-  "']'",
-  "'('",
-  "')'",
-  "'+='",
-  "'|'",
-  "'*'",
-  "'..'",
-  "'%'",
-  "'^'",
-  "'=~'",
-  "'<>'",
-  "'!='",
-  "'<'",
-  "'>'",
-  "'<='",
-  "'>='",
-  "'$'",
-  "'\u27E8'",
-  "'\u3008'",
-  "'\uFE64'",
-  "'\uFF1C'",
-  "'\u27E9'",
-  "'\u3009'",
-  "'\uFE65'",
-  "'\uFF1E'",
-  "'\u00AD'",
-  "'\u2010'",
-  "'\u2011'",
-  "'\u2012'",
-  "'\u2013'",
-  "'\u2014'",
-  "'\u2015'",
-  "'\u2212'",
-  "'\uFE58'",
-  "'\uFE63'",
-  "'\uFF0D'",
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  "'0'"
-]
-
-CypherLexer.prototype.symbolicNames = [
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  'CYPHER',
-  'EXPLAIN',
-  'PROFILE',
-  'USING',
-  'PERIODIC',
-  'COMMIT',
-  'UNION',
-  'ALL',
-  'CREATE',
-  'DROP',
-  'INDEX',
-  'ON',
-  'CONSTRAINT',
-  'ASSERT',
-  'IS',
-  'UNIQUE',
-  'EXISTS',
-  'LOAD',
-  'CSV',
-  'WITH',
-  'HEADERS',
-  'FROM',
-  'AS',
-  'FIELDTERMINATOR',
-  'OPTIONAL',
-  'MATCH',
-  'UNWIND',
-  'MERGE',
-  'SET',
-  'DETACH',
-  'DELETE',
-  'REMOVE',
-  'FOREACH',
-  'IN',
-  'DISTINCT',
-  'RETURN',
-  'ORDER',
-  'BY',
-  'L_SKIP',
-  'LIMIT',
-  'ASCENDING',
-  'ASC',
-  'DESCENDING',
-  'DESC',
-  'JOIN',
-  'SCAN',
-  'START',
-  'NODE',
-  'RELATIONSHIP',
-  'REL',
-  'WHERE',
-  'SHORTESTPATH',
-  'ALLSHORTESTPATHS',
-  'OR',
-  'XOR',
-  'AND',
-  'NOT',
-  'STARTS',
-  'ENDS',
-  'CONTAINS',
-  'NULL',
-  'COUNT',
-  'FILTER',
-  'EXTRACT',
-  'ANY',
-  'NONE',
-  'SINGLE',
-  'TRUE',
-  'FALSE',
-  'REDUCE',
-  'CASE',
-  'ELSE',
-  'END',
-  'WHEN',
-  'THEN',
-  'CALL',
-  'YIELD',
-  'KEY',
-  'StringLiteral',
-  'UrlHex',
-  'EscapedChar',
-  'HexInteger',
-  'DecimalInteger',
-  'OctalInteger',
-  'HexLetter',
-  'HexDigit',
-  'Digit',
-  'NonZeroDigit',
-  'NonZeroOctDigit',
-  'OctDigit',
-  'ZeroDigit',
-  'ExponentDecimalReal',
-  'RegularDecimalReal',
-  'UnescapedSymbolicName',
-  'IdentifierStart',
-  'IdentifierPart',
-  'EscapedSymbolicName',
-  'SP',
-  'WHITESPACE',
-  'Comment',
-  'ERROR_TOKEN'
-]
-
-CypherLexer.prototype.ruleNames = [
-  'T__0',
-  'T__1',
-  'T__2',
-  'T__3',
-  'T__4',
-  'T__5',
-  'T__6',
-  'T__7',
-  'T__8',
-  'T__9',
-  'T__10',
-  'T__11',
-  'T__12',
-  'T__13',
-  'T__14',
-  'T__15',
-  'T__16',
-  'T__17',
-  'T__18',
-  'T__19',
-  'T__20',
-  'T__21',
-  'T__22',
-  'T__23',
-  'T__24',
-  'T__25',
-  'T__26',
-  'T__27',
-  'T__28',
-  'T__29',
-  'T__30',
-  'T__31',
-  'T__32',
-  'T__33',
-  'T__34',
-  'T__35',
-  'T__36',
-  'T__37',
-  'T__38',
-  'T__39',
-  'T__40',
-  'T__41',
-  'T__42',
-  'T__43',
-  'T__44',
-  'T__45',
-  'T__46',
-  'T__47',
-  'T__48',
-  'T__49',
-  'T__50',
-  'T__51',
-  'T__52',
-  'CYPHER',
-  'EXPLAIN',
-  'PROFILE',
-  'USING',
-  'PERIODIC',
-  'COMMIT',
-  'UNION',
-  'ALL',
-  'CREATE',
-  'DROP',
-  'INDEX',
-  'ON',
-  'CONSTRAINT',
-  'ASSERT',
-  'IS',
-  'UNIQUE',
-  'EXISTS',
-  'LOAD',
-  'CSV',
-  'WITH',
-  'HEADERS',
-  'FROM',
-  'AS',
-  'FIELDTERMINATOR',
-  'OPTIONAL',
-  'MATCH',
-  'UNWIND',
-  'MERGE',
-  'SET',
-  'DETACH',
-  'DELETE',
-  'REMOVE',
-  'FOREACH',
-  'IN',
-  'DISTINCT',
-  'RETURN',
-  'ORDER',
-  'BY',
-  'L_SKIP',
-  'LIMIT',
-  'ASCENDING',
-  'ASC',
-  'DESCENDING',
-  'DESC',
-  'JOIN',
-  'SCAN',
-  'START',
-  'NODE',
-  'RELATIONSHIP',
-  'REL',
-  'WHERE',
-  'SHORTESTPATH',
-  'ALLSHORTESTPATHS',
-  'OR',
-  'XOR',
-  'AND',
-  'NOT',
-  'STARTS',
-  'ENDS',
-  'CONTAINS',
-  'NULL',
-  'COUNT',
-  'FILTER',
-  'EXTRACT',
-  'ANY',
-  'NONE',
-  'SINGLE',
-  'TRUE',
-  'FALSE',
-  'REDUCE',
-  'CASE',
-  'ELSE',
-  'END',
-  'WHEN',
-  'THEN',
-  'CALL',
-  'YIELD',
-  'KEY',
-  'StringLiteral',
-  'UrlHex',
-  'EscapedChar',
-  'HexInteger',
-  'DecimalInteger',
-  'OctalInteger',
-  'HexLetter',
-  'HexDigit',
-  'Digit',
-  'NonZeroDigit',
-  'NonZeroOctDigit',
-  'OctDigit',
-  'ZeroDigit',
-  'ExponentDecimalReal',
-  'RegularDecimalReal',
-  'UnescapedSymbolicName',
-  'IdentifierStart',
-  'IdentifierPart',
-  'EscapedSymbolicName',
-  'SP',
-  'WHITESPACE',
-  'Comment',
-  'ERROR_TOKEN',
-  'FF',
-  'RS',
-  'ID_Continue',
-  'GS',
-  'FS',
-  'CR',
-  'Sc',
-  'SPACE',
-  'TAB',
-  'LF',
-  'VT',
-  'US',
-  'ID_Start',
-  'A',
-  'B',
-  'C',
-  'D',
-  'E',
-  'F',
-  'G',
-  'H',
-  'I',
-  'J',
-  'K',
-  'L',
-  'M',
-  'N',
-  'O',
-  'P',
-  'Q',
-  'R',
-  'S',
-  'T',
-  'U',
-  'V',
-  'W',
-  'X',
-  'Y',
-  'Z'
-]
-
-CypherLexer.prototype.grammarFileName = 'Cypher.g4'
-
-exports.CypherLexer = CypherLexer
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js b/src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js
deleted file mode 100644
index 779d59910c2..00000000000
--- a/src/browser/modules/Editor/antlr-cypher-parser/CypherListener.js
+++ /dev/null
@@ -1,1268 +0,0 @@
-// Generated from cypher-editor-support/src/_generated.simple/Cypher.g4 by ANTLR 4.7
-// jshint ignore: start
-var antlr4 = require('antlr4/index')
-
-// This class defines a complete listener for a parse tree produced by CypherParser.
-function CypherListener() {
-  antlr4.tree.ParseTreeListener.call(this)
-  return this
-}
-
-CypherListener.prototype = Object.create(
-  antlr4.tree.ParseTreeListener.prototype
-)
-CypherListener.prototype.constructor = CypherListener
-
-// Enter a parse tree produced by CypherParser#raw.
-CypherListener.prototype.enterRaw = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#raw.
-CypherListener.prototype.exitRaw = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypher.
-CypherListener.prototype.enterCypher = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypher.
-CypherListener.prototype.exitCypher = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypherPart.
-CypherListener.prototype.enterCypherPart = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypherPart.
-CypherListener.prototype.exitCypherPart = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypherConsoleCommand.
-CypherListener.prototype.enterCypherConsoleCommand = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypherConsoleCommand.
-CypherListener.prototype.exitCypherConsoleCommand = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypherConsoleCommandName.
-CypherListener.prototype.enterCypherConsoleCommandName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypherConsoleCommandName.
-CypherListener.prototype.exitCypherConsoleCommandName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypherConsoleCommandParameters.
-CypherListener.prototype.enterCypherConsoleCommandParameters = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypherConsoleCommandParameters.
-CypherListener.prototype.exitCypherConsoleCommandParameters = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypherConsoleCommandParameter.
-CypherListener.prototype.enterCypherConsoleCommandParameter = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypherConsoleCommandParameter.
-CypherListener.prototype.exitCypherConsoleCommandParameter = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#arrowExpression.
-CypherListener.prototype.enterArrowExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#arrowExpression.
-CypherListener.prototype.exitArrowExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#url.
-CypherListener.prototype.enterUrl = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#url.
-CypherListener.prototype.exitUrl = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#uri.
-CypherListener.prototype.enterUri = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#uri.
-CypherListener.prototype.exitUri = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#scheme.
-CypherListener.prototype.enterScheme = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#scheme.
-CypherListener.prototype.exitScheme = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#host.
-CypherListener.prototype.enterHost = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#host.
-CypherListener.prototype.exitHost = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#hostname.
-CypherListener.prototype.enterHostname = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#hostname.
-CypherListener.prototype.exitHostname = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#hostnumber.
-CypherListener.prototype.enterHostnumber = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#hostnumber.
-CypherListener.prototype.exitHostnumber = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#port.
-CypherListener.prototype.enterPort = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#port.
-CypherListener.prototype.exitPort = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#path.
-CypherListener.prototype.enterPath = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#path.
-CypherListener.prototype.exitPath = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#user.
-CypherListener.prototype.enterUser = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#user.
-CypherListener.prototype.exitUser = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#login.
-CypherListener.prototype.enterLogin = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#login.
-CypherListener.prototype.exitLogin = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#password.
-CypherListener.prototype.enterPassword = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#password.
-CypherListener.prototype.exitPassword = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#frag.
-CypherListener.prototype.enterFrag = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#frag.
-CypherListener.prototype.exitFrag = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#urlQuery.
-CypherListener.prototype.enterUrlQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#urlQuery.
-CypherListener.prototype.exitUrlQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#search.
-CypherListener.prototype.enterSearch = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#search.
-CypherListener.prototype.exitSearch = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#searchparameter.
-CypherListener.prototype.enterSearchparameter = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#searchparameter.
-CypherListener.prototype.exitSearchparameter = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#string.
-CypherListener.prototype.enterString = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#string.
-CypherListener.prototype.exitString = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#urlDigits.
-CypherListener.prototype.enterUrlDigits = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#urlDigits.
-CypherListener.prototype.exitUrlDigits = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#json.
-CypherListener.prototype.enterJson = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#json.
-CypherListener.prototype.exitJson = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#obj.
-CypherListener.prototype.enterObj = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#obj.
-CypherListener.prototype.exitObj = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#pair.
-CypherListener.prototype.enterPair = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#pair.
-CypherListener.prototype.exitPair = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#array.
-CypherListener.prototype.enterArray = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#array.
-CypherListener.prototype.exitArray = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#value.
-CypherListener.prototype.enterValue = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#value.
-CypherListener.prototype.exitValue = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#keyValueLiteral.
-CypherListener.prototype.enterKeyValueLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#keyValueLiteral.
-CypherListener.prototype.exitKeyValueLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#commandPath.
-CypherListener.prototype.enterCommandPath = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#commandPath.
-CypherListener.prototype.exitCommandPath = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#subCommand.
-CypherListener.prototype.enterSubCommand = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#subCommand.
-CypherListener.prototype.exitSubCommand = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypherQuery.
-CypherListener.prototype.enterCypherQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypherQuery.
-CypherListener.prototype.exitCypherQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#queryOptions.
-CypherListener.prototype.enterQueryOptions = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#queryOptions.
-CypherListener.prototype.exitQueryOptions = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#anyCypherOption.
-CypherListener.prototype.enterAnyCypherOption = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#anyCypherOption.
-CypherListener.prototype.exitAnyCypherOption = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#cypherOption.
-CypherListener.prototype.enterCypherOption = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#cypherOption.
-CypherListener.prototype.exitCypherOption = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#versionNumber.
-CypherListener.prototype.enterVersionNumber = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#versionNumber.
-CypherListener.prototype.exitVersionNumber = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#explain.
-CypherListener.prototype.enterExplain = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#explain.
-CypherListener.prototype.exitExplain = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#profile.
-CypherListener.prototype.enterProfile = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#profile.
-CypherListener.prototype.exitProfile = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#configurationOption.
-CypherListener.prototype.enterConfigurationOption = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#configurationOption.
-CypherListener.prototype.exitConfigurationOption = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#statement.
-CypherListener.prototype.enterStatement = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#statement.
-CypherListener.prototype.exitStatement = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#query.
-CypherListener.prototype.enterQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#query.
-CypherListener.prototype.exitQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#regularQuery.
-CypherListener.prototype.enterRegularQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#regularQuery.
-CypherListener.prototype.exitRegularQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#bulkImportQuery.
-CypherListener.prototype.enterBulkImportQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#bulkImportQuery.
-CypherListener.prototype.exitBulkImportQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#singleQuery.
-CypherListener.prototype.enterSingleQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#singleQuery.
-CypherListener.prototype.exitSingleQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#periodicCommitHint.
-CypherListener.prototype.enterPeriodicCommitHint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#periodicCommitHint.
-CypherListener.prototype.exitPeriodicCommitHint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#loadCSVQuery.
-CypherListener.prototype.enterLoadCSVQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#loadCSVQuery.
-CypherListener.prototype.exitLoadCSVQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#union.
-CypherListener.prototype.enterUnion = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#union.
-CypherListener.prototype.exitUnion = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#clause.
-CypherListener.prototype.enterClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#clause.
-CypherListener.prototype.exitClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#command.
-CypherListener.prototype.enterCommand = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#command.
-CypherListener.prototype.exitCommand = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#createUniqueConstraint.
-CypherListener.prototype.enterCreateUniqueConstraint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#createUniqueConstraint.
-CypherListener.prototype.exitCreateUniqueConstraint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#createNodeKeyConstraint.
-CypherListener.prototype.enterCreateNodeKeyConstraint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#createNodeKeyConstraint.
-CypherListener.prototype.exitCreateNodeKeyConstraint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#createNodePropertyExistenceConstraint.
-CypherListener.prototype.enterCreateNodePropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Exit a parse tree produced by CypherParser#createNodePropertyExistenceConstraint.
-CypherListener.prototype.exitCreateNodePropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Enter a parse tree produced by CypherParser#createRelationshipPropertyExistenceConstraint.
-CypherListener.prototype.enterCreateRelationshipPropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Exit a parse tree produced by CypherParser#createRelationshipPropertyExistenceConstraint.
-CypherListener.prototype.exitCreateRelationshipPropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Enter a parse tree produced by CypherParser#createIndex.
-CypherListener.prototype.enterCreateIndex = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#createIndex.
-CypherListener.prototype.exitCreateIndex = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#dropUniqueConstraint.
-CypherListener.prototype.enterDropUniqueConstraint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#dropUniqueConstraint.
-CypherListener.prototype.exitDropUniqueConstraint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#dropNodeKeyConstraint.
-CypherListener.prototype.enterDropNodeKeyConstraint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#dropNodeKeyConstraint.
-CypherListener.prototype.exitDropNodeKeyConstraint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#dropNodePropertyExistenceConstraint.
-CypherListener.prototype.enterDropNodePropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Exit a parse tree produced by CypherParser#dropNodePropertyExistenceConstraint.
-CypherListener.prototype.exitDropNodePropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Enter a parse tree produced by CypherParser#dropRelationshipPropertyExistenceConstraint.
-CypherListener.prototype.enterDropRelationshipPropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Exit a parse tree produced by CypherParser#dropRelationshipPropertyExistenceConstraint.
-CypherListener.prototype.exitDropRelationshipPropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Enter a parse tree produced by CypherParser#dropIndex.
-CypherListener.prototype.enterDropIndex = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#dropIndex.
-CypherListener.prototype.exitDropIndex = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#index.
-CypherListener.prototype.enterIndex = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#index.
-CypherListener.prototype.exitIndex = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#uniqueConstraint.
-CypherListener.prototype.enterUniqueConstraint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#uniqueConstraint.
-CypherListener.prototype.exitUniqueConstraint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#nodeKeyConstraint.
-CypherListener.prototype.enterNodeKeyConstraint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#nodeKeyConstraint.
-CypherListener.prototype.exitNodeKeyConstraint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#nodePropertyExistenceConstraint.
-CypherListener.prototype.enterNodePropertyExistenceConstraint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#nodePropertyExistenceConstraint.
-CypherListener.prototype.exitNodePropertyExistenceConstraint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipPropertyExistenceConstraint.
-CypherListener.prototype.enterRelationshipPropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Exit a parse tree produced by CypherParser#relationshipPropertyExistenceConstraint.
-CypherListener.prototype.exitRelationshipPropertyExistenceConstraint = function(
-  ctx
-) {}
-
-// Enter a parse tree produced by CypherParser#relationshipPatternSyntax.
-CypherListener.prototype.enterRelationshipPatternSyntax = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipPatternSyntax.
-CypherListener.prototype.exitRelationshipPatternSyntax = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#loadCSVClause.
-CypherListener.prototype.enterLoadCSVClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#loadCSVClause.
-CypherListener.prototype.exitLoadCSVClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#matchClause.
-CypherListener.prototype.enterMatchClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#matchClause.
-CypherListener.prototype.exitMatchClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#unwindClause.
-CypherListener.prototype.enterUnwindClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#unwindClause.
-CypherListener.prototype.exitUnwindClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#mergeClause.
-CypherListener.prototype.enterMergeClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#mergeClause.
-CypherListener.prototype.exitMergeClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#mergeAction.
-CypherListener.prototype.enterMergeAction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#mergeAction.
-CypherListener.prototype.exitMergeAction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#createClause.
-CypherListener.prototype.enterCreateClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#createClause.
-CypherListener.prototype.exitCreateClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#createUniqueClause.
-CypherListener.prototype.enterCreateUniqueClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#createUniqueClause.
-CypherListener.prototype.exitCreateUniqueClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#setClause.
-CypherListener.prototype.enterSetClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#setClause.
-CypherListener.prototype.exitSetClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#setItem.
-CypherListener.prototype.enterSetItem = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#setItem.
-CypherListener.prototype.exitSetItem = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#deleteClause.
-CypherListener.prototype.enterDeleteClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#deleteClause.
-CypherListener.prototype.exitDeleteClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#removeClause.
-CypherListener.prototype.enterRemoveClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#removeClause.
-CypherListener.prototype.exitRemoveClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#removeItem.
-CypherListener.prototype.enterRemoveItem = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#removeItem.
-CypherListener.prototype.exitRemoveItem = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#foreachClause.
-CypherListener.prototype.enterForeachClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#foreachClause.
-CypherListener.prototype.exitForeachClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#withClause.
-CypherListener.prototype.enterWithClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#withClause.
-CypherListener.prototype.exitWithClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#returnClause.
-CypherListener.prototype.enterReturnClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#returnClause.
-CypherListener.prototype.exitReturnClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#returnBody.
-CypherListener.prototype.enterReturnBody = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#returnBody.
-CypherListener.prototype.exitReturnBody = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#func.
-CypherListener.prototype.enterFunc = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#func.
-CypherListener.prototype.exitFunc = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#returnItems.
-CypherListener.prototype.enterReturnItems = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#returnItems.
-CypherListener.prototype.exitReturnItems = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#returnItem.
-CypherListener.prototype.enterReturnItem = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#returnItem.
-CypherListener.prototype.exitReturnItem = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#call.
-CypherListener.prototype.enterCall = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#call.
-CypherListener.prototype.exitCall = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#procedureInvocation.
-CypherListener.prototype.enterProcedureInvocation = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#procedureInvocation.
-CypherListener.prototype.exitProcedureInvocation = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#procedureInvocationBody.
-CypherListener.prototype.enterProcedureInvocationBody = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#procedureInvocationBody.
-CypherListener.prototype.exitProcedureInvocationBody = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#procedureArguments.
-CypherListener.prototype.enterProcedureArguments = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#procedureArguments.
-CypherListener.prototype.exitProcedureArguments = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#procedureResults.
-CypherListener.prototype.enterProcedureResults = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#procedureResults.
-CypherListener.prototype.exitProcedureResults = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#procedureResult.
-CypherListener.prototype.enterProcedureResult = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#procedureResult.
-CypherListener.prototype.exitProcedureResult = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#aliasedProcedureResult.
-CypherListener.prototype.enterAliasedProcedureResult = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#aliasedProcedureResult.
-CypherListener.prototype.exitAliasedProcedureResult = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#simpleProcedureResult.
-CypherListener.prototype.enterSimpleProcedureResult = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#simpleProcedureResult.
-CypherListener.prototype.exitSimpleProcedureResult = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#procedureOutput.
-CypherListener.prototype.enterProcedureOutput = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#procedureOutput.
-CypherListener.prototype.exitProcedureOutput = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#order.
-CypherListener.prototype.enterOrder = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#order.
-CypherListener.prototype.exitOrder = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#skip.
-CypherListener.prototype.enterSkip = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#skip.
-CypherListener.prototype.exitSkip = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#limit.
-CypherListener.prototype.enterLimit = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#limit.
-CypherListener.prototype.exitLimit = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#sortItem.
-CypherListener.prototype.enterSortItem = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#sortItem.
-CypherListener.prototype.exitSortItem = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#hint.
-CypherListener.prototype.enterHint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#hint.
-CypherListener.prototype.exitHint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#startClause.
-CypherListener.prototype.enterStartClause = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#startClause.
-CypherListener.prototype.exitStartClause = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#startPoint.
-CypherListener.prototype.enterStartPoint = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#startPoint.
-CypherListener.prototype.exitStartPoint = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#lookup.
-CypherListener.prototype.enterLookup = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#lookup.
-CypherListener.prototype.exitLookup = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#nodeLookup.
-CypherListener.prototype.enterNodeLookup = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#nodeLookup.
-CypherListener.prototype.exitNodeLookup = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipLookup.
-CypherListener.prototype.enterRelationshipLookup = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipLookup.
-CypherListener.prototype.exitRelationshipLookup = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#identifiedIndexLookup.
-CypherListener.prototype.enterIdentifiedIndexLookup = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#identifiedIndexLookup.
-CypherListener.prototype.exitIdentifiedIndexLookup = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#indexQuery.
-CypherListener.prototype.enterIndexQuery = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#indexQuery.
-CypherListener.prototype.exitIndexQuery = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#idLookup.
-CypherListener.prototype.enterIdLookup = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#idLookup.
-CypherListener.prototype.exitIdLookup = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#literalIds.
-CypherListener.prototype.enterLiteralIds = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#literalIds.
-CypherListener.prototype.exitLiteralIds = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#where.
-CypherListener.prototype.enterWhere = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#where.
-CypherListener.prototype.exitWhere = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#pattern.
-CypherListener.prototype.enterPattern = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#pattern.
-CypherListener.prototype.exitPattern = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#patternPart.
-CypherListener.prototype.enterPatternPart = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#patternPart.
-CypherListener.prototype.exitPatternPart = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#anonymousPatternPart.
-CypherListener.prototype.enterAnonymousPatternPart = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#anonymousPatternPart.
-CypherListener.prototype.exitAnonymousPatternPart = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#patternElement.
-CypherListener.prototype.enterPatternElement = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#patternElement.
-CypherListener.prototype.exitPatternElement = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#nodePattern.
-CypherListener.prototype.enterNodePattern = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#nodePattern.
-CypherListener.prototype.exitNodePattern = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#patternElementChain.
-CypherListener.prototype.enterPatternElementChain = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#patternElementChain.
-CypherListener.prototype.exitPatternElementChain = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipPattern.
-CypherListener.prototype.enterRelationshipPattern = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipPattern.
-CypherListener.prototype.exitRelationshipPattern = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipPatternStart.
-CypherListener.prototype.enterRelationshipPatternStart = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipPatternStart.
-CypherListener.prototype.exitRelationshipPatternStart = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipPatternEnd.
-CypherListener.prototype.enterRelationshipPatternEnd = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipPatternEnd.
-CypherListener.prototype.exitRelationshipPatternEnd = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipDetail.
-CypherListener.prototype.enterRelationshipDetail = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipDetail.
-CypherListener.prototype.exitRelationshipDetail = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#properties.
-CypherListener.prototype.enterProperties = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#properties.
-CypherListener.prototype.exitProperties = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relType.
-CypherListener.prototype.enterRelType = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relType.
-CypherListener.prototype.exitRelType = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipTypes.
-CypherListener.prototype.enterRelationshipTypes = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipTypes.
-CypherListener.prototype.exitRelationshipTypes = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipType.
-CypherListener.prototype.enterRelationshipType = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipType.
-CypherListener.prototype.exitRelationshipType = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipTypeOptionalColon.
-CypherListener.prototype.enterRelationshipTypeOptionalColon = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipTypeOptionalColon.
-CypherListener.prototype.exitRelationshipTypeOptionalColon = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#nodeLabels.
-CypherListener.prototype.enterNodeLabels = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#nodeLabels.
-CypherListener.prototype.exitNodeLabels = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#nodeLabel.
-CypherListener.prototype.enterNodeLabel = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#nodeLabel.
-CypherListener.prototype.exitNodeLabel = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#rangeLiteral.
-CypherListener.prototype.enterRangeLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#rangeLiteral.
-CypherListener.prototype.exitRangeLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#labelName.
-CypherListener.prototype.enterLabelName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#labelName.
-CypherListener.prototype.exitLabelName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relTypeName.
-CypherListener.prototype.enterRelTypeName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relTypeName.
-CypherListener.prototype.exitRelTypeName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#expression.
-CypherListener.prototype.enterExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#expression.
-CypherListener.prototype.exitExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#orExpression.
-CypherListener.prototype.enterOrExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#orExpression.
-CypherListener.prototype.exitOrExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#xorExpression.
-CypherListener.prototype.enterXorExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#xorExpression.
-CypherListener.prototype.exitXorExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#andExpression.
-CypherListener.prototype.enterAndExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#andExpression.
-CypherListener.prototype.exitAndExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#notExpression.
-CypherListener.prototype.enterNotExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#notExpression.
-CypherListener.prototype.exitNotExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#comparisonExpression.
-CypherListener.prototype.enterComparisonExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#comparisonExpression.
-CypherListener.prototype.exitComparisonExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#addOrSubtractExpression.
-CypherListener.prototype.enterAddOrSubtractExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#addOrSubtractExpression.
-CypherListener.prototype.exitAddOrSubtractExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#multiplyDivideModuloExpression.
-CypherListener.prototype.enterMultiplyDivideModuloExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#multiplyDivideModuloExpression.
-CypherListener.prototype.exitMultiplyDivideModuloExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#powerOfExpression.
-CypherListener.prototype.enterPowerOfExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#powerOfExpression.
-CypherListener.prototype.exitPowerOfExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#unaryAddOrSubtractExpression.
-CypherListener.prototype.enterUnaryAddOrSubtractExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#unaryAddOrSubtractExpression.
-CypherListener.prototype.exitUnaryAddOrSubtractExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#stringListNullOperatorExpression.
-CypherListener.prototype.enterStringListNullOperatorExpression = function(
-  ctx
-) {}
-
-// Exit a parse tree produced by CypherParser#stringListNullOperatorExpression.
-CypherListener.prototype.exitStringListNullOperatorExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#propertyOrLabelsExpression.
-CypherListener.prototype.enterPropertyOrLabelsExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#propertyOrLabelsExpression.
-CypherListener.prototype.exitPropertyOrLabelsExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#filterFunction.
-CypherListener.prototype.enterFilterFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#filterFunction.
-CypherListener.prototype.exitFilterFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#filterFunctionName.
-CypherListener.prototype.enterFilterFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#filterFunctionName.
-CypherListener.prototype.exitFilterFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#existsFunction.
-CypherListener.prototype.enterExistsFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#existsFunction.
-CypherListener.prototype.exitExistsFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#existsFunctionName.
-CypherListener.prototype.enterExistsFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#existsFunctionName.
-CypherListener.prototype.exitExistsFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#allFunction.
-CypherListener.prototype.enterAllFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#allFunction.
-CypherListener.prototype.exitAllFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#allFunctionName.
-CypherListener.prototype.enterAllFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#allFunctionName.
-CypherListener.prototype.exitAllFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#anyFunction.
-CypherListener.prototype.enterAnyFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#anyFunction.
-CypherListener.prototype.exitAnyFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#anyFunctionName.
-CypherListener.prototype.enterAnyFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#anyFunctionName.
-CypherListener.prototype.exitAnyFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#noneFunction.
-CypherListener.prototype.enterNoneFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#noneFunction.
-CypherListener.prototype.exitNoneFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#noneFunctionName.
-CypherListener.prototype.enterNoneFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#noneFunctionName.
-CypherListener.prototype.exitNoneFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#singleFunction.
-CypherListener.prototype.enterSingleFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#singleFunction.
-CypherListener.prototype.exitSingleFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#singleFunctionName.
-CypherListener.prototype.enterSingleFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#singleFunctionName.
-CypherListener.prototype.exitSingleFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#extractFunction.
-CypherListener.prototype.enterExtractFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#extractFunction.
-CypherListener.prototype.exitExtractFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#extractFunctionName.
-CypherListener.prototype.enterExtractFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#extractFunctionName.
-CypherListener.prototype.exitExtractFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#reduceFunction.
-CypherListener.prototype.enterReduceFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#reduceFunction.
-CypherListener.prototype.exitReduceFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#reduceFunctionName.
-CypherListener.prototype.enterReduceFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#reduceFunctionName.
-CypherListener.prototype.exitReduceFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#shortestPathPatternFunction.
-CypherListener.prototype.enterShortestPathPatternFunction = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#shortestPathPatternFunction.
-CypherListener.prototype.exitShortestPathPatternFunction = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#shortestPathFunctionName.
-CypherListener.prototype.enterShortestPathFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#shortestPathFunctionName.
-CypherListener.prototype.exitShortestPathFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#allShortestPathFunctionName.
-CypherListener.prototype.enterAllShortestPathFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#allShortestPathFunctionName.
-CypherListener.prototype.exitAllShortestPathFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#atom.
-CypherListener.prototype.enterAtom = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#atom.
-CypherListener.prototype.exitAtom = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#literal.
-CypherListener.prototype.enterLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#literal.
-CypherListener.prototype.exitLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#stringLiteral.
-CypherListener.prototype.enterStringLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#stringLiteral.
-CypherListener.prototype.exitStringLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#booleanLiteral.
-CypherListener.prototype.enterBooleanLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#booleanLiteral.
-CypherListener.prototype.exitBooleanLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#listLiteral.
-CypherListener.prototype.enterListLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#listLiteral.
-CypherListener.prototype.exitListLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#partialComparisonExpression.
-CypherListener.prototype.enterPartialComparisonExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#partialComparisonExpression.
-CypherListener.prototype.exitPartialComparisonExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#parenthesizedExpression.
-CypherListener.prototype.enterParenthesizedExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#parenthesizedExpression.
-CypherListener.prototype.exitParenthesizedExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#relationshipsPattern.
-CypherListener.prototype.enterRelationshipsPattern = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#relationshipsPattern.
-CypherListener.prototype.exitRelationshipsPattern = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#filterExpression.
-CypherListener.prototype.enterFilterExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#filterExpression.
-CypherListener.prototype.exitFilterExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#idInColl.
-CypherListener.prototype.enterIdInColl = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#idInColl.
-CypherListener.prototype.exitIdInColl = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#functionInvocation.
-CypherListener.prototype.enterFunctionInvocation = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#functionInvocation.
-CypherListener.prototype.exitFunctionInvocation = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#functionInvocationBody.
-CypherListener.prototype.enterFunctionInvocationBody = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#functionInvocationBody.
-CypherListener.prototype.exitFunctionInvocationBody = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#functionName.
-CypherListener.prototype.enterFunctionName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#functionName.
-CypherListener.prototype.exitFunctionName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#procedureName.
-CypherListener.prototype.enterProcedureName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#procedureName.
-CypherListener.prototype.exitProcedureName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#listComprehension.
-CypherListener.prototype.enterListComprehension = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#listComprehension.
-CypherListener.prototype.exitListComprehension = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#patternComprehension.
-CypherListener.prototype.enterPatternComprehension = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#patternComprehension.
-CypherListener.prototype.exitPatternComprehension = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#propertyLookup.
-CypherListener.prototype.enterPropertyLookup = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#propertyLookup.
-CypherListener.prototype.exitPropertyLookup = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#caseExpression.
-CypherListener.prototype.enterCaseExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#caseExpression.
-CypherListener.prototype.exitCaseExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#caseAlternatives.
-CypherListener.prototype.enterCaseAlternatives = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#caseAlternatives.
-CypherListener.prototype.exitCaseAlternatives = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#variable.
-CypherListener.prototype.enterVariable = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#variable.
-CypherListener.prototype.exitVariable = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#numberLiteral.
-CypherListener.prototype.enterNumberLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#numberLiteral.
-CypherListener.prototype.exitNumberLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#mapLiteral.
-CypherListener.prototype.enterMapLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#mapLiteral.
-CypherListener.prototype.exitMapLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#mapProjection.
-CypherListener.prototype.enterMapProjection = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#mapProjection.
-CypherListener.prototype.exitMapProjection = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#mapProjectionVariants.
-CypherListener.prototype.enterMapProjectionVariants = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#mapProjectionVariants.
-CypherListener.prototype.exitMapProjectionVariants = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#literalEntry.
-CypherListener.prototype.enterLiteralEntry = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#literalEntry.
-CypherListener.prototype.exitLiteralEntry = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#propertySelector.
-CypherListener.prototype.enterPropertySelector = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#propertySelector.
-CypherListener.prototype.exitPropertySelector = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#variableSelector.
-CypherListener.prototype.enterVariableSelector = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#variableSelector.
-CypherListener.prototype.exitVariableSelector = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#allPropertiesSelector.
-CypherListener.prototype.enterAllPropertiesSelector = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#allPropertiesSelector.
-CypherListener.prototype.exitAllPropertiesSelector = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#parameter.
-CypherListener.prototype.enterParameter = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#parameter.
-CypherListener.prototype.exitParameter = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#legacyParameter.
-CypherListener.prototype.enterLegacyParameter = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#legacyParameter.
-CypherListener.prototype.exitLegacyParameter = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#newParameter.
-CypherListener.prototype.enterNewParameter = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#newParameter.
-CypherListener.prototype.exitNewParameter = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#parameterName.
-CypherListener.prototype.enterParameterName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#parameterName.
-CypherListener.prototype.exitParameterName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#propertyExpressions.
-CypherListener.prototype.enterPropertyExpressions = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#propertyExpressions.
-CypherListener.prototype.exitPropertyExpressions = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#propertyExpression.
-CypherListener.prototype.enterPropertyExpression = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#propertyExpression.
-CypherListener.prototype.exitPropertyExpression = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#propertyKeys.
-CypherListener.prototype.enterPropertyKeys = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#propertyKeys.
-CypherListener.prototype.exitPropertyKeys = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#propertyKeyName.
-CypherListener.prototype.enterPropertyKeyName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#propertyKeyName.
-CypherListener.prototype.exitPropertyKeyName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#integerLiteral.
-CypherListener.prototype.enterIntegerLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#integerLiteral.
-CypherListener.prototype.exitIntegerLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#doubleLiteral.
-CypherListener.prototype.enterDoubleLiteral = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#doubleLiteral.
-CypherListener.prototype.exitDoubleLiteral = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#namespace.
-CypherListener.prototype.enterNamespace = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#namespace.
-CypherListener.prototype.exitNamespace = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#leftArrowHead.
-CypherListener.prototype.enterLeftArrowHead = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#leftArrowHead.
-CypherListener.prototype.exitLeftArrowHead = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#rightArrowHead.
-CypherListener.prototype.enterRightArrowHead = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#rightArrowHead.
-CypherListener.prototype.exitRightArrowHead = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#dash.
-CypherListener.prototype.enterDash = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#dash.
-CypherListener.prototype.exitDash = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#symbolicName.
-CypherListener.prototype.enterSymbolicName = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#symbolicName.
-CypherListener.prototype.exitSymbolicName = function(ctx) {}
-
-// Enter a parse tree produced by CypherParser#keyword.
-CypherListener.prototype.enterKeyword = function(ctx) {}
-
-// Exit a parse tree produced by CypherParser#keyword.
-CypherListener.prototype.exitKeyword = function(ctx) {}
-
-exports.CypherListener = CypherListener
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js b/src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js
deleted file mode 100644
index de867f0f7cc..00000000000
--- a/src/browser/modules/Editor/antlr-cypher-parser/CypherParser.js
+++ /dev/null
@@ -1,24555 +0,0 @@
-// Generated from cypher-editor-support/src/_generated/Cypher.g4 by ANTLR 4.7
-// jshint ignore: start
-var antlr4 = require('antlr4')
-var CypherListener = require('./CypherListener').CypherListener
-var grammarFileName = 'Cypher.g4'
-
-var serializedATN = [
-  '\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964',
-  '\u0003\u009c\u0a7b\u0004\u0002\t\u0002\u0004\u0003\t\u0003\u0004\u0004',
-  '\t\u0004\u0004\u0005\t\u0005\u0004\u0006\t\u0006\u0004\u0007\t\u0007',
-  '\u0004\b\t\b\u0004\t\t\t\u0004\n\t\n\u0004\u000b\t\u000b\u0004\f\t\f',
-  '\u0004\r\t\r\u0004\u000e\t\u000e\u0004\u000f\t\u000f\u0004\u0010\t\u0010',
-  '\u0004\u0011\t\u0011\u0004\u0012\t\u0012\u0004\u0013\t\u0013\u0004\u0014',
-  '\t\u0014\u0004\u0015\t\u0015\u0004\u0016\t\u0016\u0004\u0017\t\u0017',
-  '\u0004\u0018\t\u0018\u0004\u0019\t\u0019\u0004\u001a\t\u001a\u0004\u001b',
-  '\t\u001b\u0004\u001c\t\u001c\u0004\u001d\t\u001d\u0004\u001e\t\u001e',
-  '\u0004\u001f\t\u001f\u0004 \t \u0004!\t!\u0004"\t"\u0004#\t#\u0004',
-  "$\t$\u0004%\t%\u0004&\t&\u0004'\t'\u0004(\t(\u0004)\t)\u0004*\t*\u0004",
-  '+\t+\u0004,\t,\u0004-\t-\u0004.\t.\u0004/\t/\u00040\t0\u00041\t1\u0004',
-  '2\t2\u00043\t3\u00044\t4\u00045\t5\u00046\t6\u00047\t7\u00048\t8\u0004',
-  '9\t9\u0004:\t:\u0004;\t;\u0004<\t<\u0004=\t=\u0004>\t>\u0004?\t?\u0004',
-  '@\t@\u0004A\tA\u0004B\tB\u0004C\tC\u0004D\tD\u0004E\tE\u0004F\tF\u0004',
-  'G\tG\u0004H\tH\u0004I\tI\u0004J\tJ\u0004K\tK\u0004L\tL\u0004M\tM\u0004',
-  'N\tN\u0004O\tO\u0004P\tP\u0004Q\tQ\u0004R\tR\u0004S\tS\u0004T\tT\u0004',
-  'U\tU\u0004V\tV\u0004W\tW\u0004X\tX\u0004Y\tY\u0004Z\tZ\u0004[\t[\u0004',
-  '\\\t\\\u0004]\t]\u0004^\t^\u0004_\t_\u0004`\t`\u0004a\ta\u0004b\tb\u0004',
-  'c\tc\u0004d\td\u0004e\te\u0004f\tf\u0004g\tg\u0004h\th\u0004i\ti\u0004',
-  'j\tj\u0004k\tk\u0004l\tl\u0004m\tm\u0004n\tn\u0004o\to\u0004p\tp\u0004',
-  'q\tq\u0004r\tr\u0004s\ts\u0004t\tt\u0004u\tu\u0004v\tv\u0004w\tw\u0004',
-  'x\tx\u0004y\ty\u0004z\tz\u0004{\t{\u0004|\t|\u0004}\t}\u0004~\t~\u0004',
-  '\u007f\t\u007f\u0004\u0080\t\u0080\u0004\u0081\t\u0081\u0004\u0082\t',
-  '\u0082\u0004\u0083\t\u0083\u0004\u0084\t\u0084\u0004\u0085\t\u0085\u0004',
-  '\u0086\t\u0086\u0004\u0087\t\u0087\u0004\u0088\t\u0088\u0004\u0089\t',
-  '\u0089\u0004\u008a\t\u008a\u0004\u008b\t\u008b\u0004\u008c\t\u008c\u0004',
-  '\u008d\t\u008d\u0004\u008e\t\u008e\u0004\u008f\t\u008f\u0004\u0090\t',
-  '\u0090\u0004\u0091\t\u0091\u0004\u0092\t\u0092\u0004\u0093\t\u0093\u0004',
-  '\u0094\t\u0094\u0004\u0095\t\u0095\u0004\u0096\t\u0096\u0004\u0097\t',
-  '\u0097\u0004\u0098\t\u0098\u0004\u0099\t\u0099\u0004\u009a\t\u009a\u0004',
-  '\u009b\t\u009b\u0004\u009c\t\u009c\u0004\u009d\t\u009d\u0004\u009e\t',
-  '\u009e\u0004\u009f\t\u009f\u0004\u00a0\t\u00a0\u0004\u00a1\t\u00a1\u0004',
-  '\u00a2\t\u00a2\u0004\u00a3\t\u00a3\u0004\u00a4\t\u00a4\u0004\u00a5\t',
-  '\u00a5\u0004\u00a6\t\u00a6\u0004\u00a7\t\u00a7\u0004\u00a8\t\u00a8\u0004',
-  '\u00a9\t\u00a9\u0004\u00aa\t\u00aa\u0004\u00ab\t\u00ab\u0004\u00ac\t',
-  '\u00ac\u0004\u00ad\t\u00ad\u0004\u00ae\t\u00ae\u0004\u00af\t\u00af\u0004',
-  '\u00b0\t\u00b0\u0004\u00b1\t\u00b1\u0004\u00b2\t\u00b2\u0004\u00b3\t',
-  '\u00b3\u0004\u00b4\t\u00b4\u0004\u00b5\t\u00b5\u0004\u00b6\t\u00b6\u0004',
-  '\u00b7\t\u00b7\u0004\u00b8\t\u00b8\u0004\u00b9\t\u00b9\u0004\u00ba\t',
-  '\u00ba\u0004\u00bb\t\u00bb\u0004\u00bc\t\u00bc\u0004\u00bd\t\u00bd\u0004',
-  '\u00be\t\u00be\u0004\u00bf\t\u00bf\u0004\u00c0\t\u00c0\u0004\u00c1\t',
-  '\u00c1\u0004\u00c2\t\u00c2\u0004\u00c3\t\u00c3\u0004\u00c4\t\u00c4\u0004',
-  '\u00c5\t\u00c5\u0004\u00c6\t\u00c6\u0004\u00c7\t\u00c7\u0004\u00c8\t',
-  '\u00c8\u0004\u00c9\t\u00c9\u0004\u00ca\t\u00ca\u0004\u00cb\t\u00cb\u0004',
-  '\u00cc\t\u00cc\u0003\u0002\u0003\u0002\u0003\u0002\u0007\u0002\u019c',
-  '\n\u0002\f\u0002\u000e\u0002\u019f\u000b\u0002\u0003\u0002\u0005\u0002',
-  '\u01a2\n\u0002\u0003\u0002\u0003\u0002\u0003\u0003\u0005\u0003\u01a7',
-  '\n\u0003\u0003\u0003\u0003\u0003\u0005\u0003\u01ab\n\u0003\u0003\u0003',
-  '\u0005\u0003\u01ae\n\u0003\u0003\u0004\u0003\u0004\u0003\u0004\u0005',
-  '\u0004\u01b3\n\u0004\u0003\u0005\u0003\u0005\u0003\u0005\u0003\u0005',
-  '\u0007\u0005\u01b9\n\u0005\f\u0005\u000e\u0005\u01bc\u000b\u0005\u0003',
-  '\u0006\u0003\u0006\u0003\u0006\u0007\u0006\u01c1\n\u0006\f\u0006\u000e',
-  '\u0006\u01c4\u000b\u0006\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007',
-  '\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007\u0003\u0007',
-  '\u0005\u0007\u01d0\n\u0007\u0003\b\u0003\b\u0005\b\u01d4\n\b\u0003\b',
-  '\u0003\b\u0005\b\u01d8\n\b\u0003\b\u0003\b\u0003\t\u0003\t\u0003\n\u0003',
-  '\n\u0003\n\u0005\n\u01e1\n\n\u0003\n\u0003\n\u0003\n\u0005\n\u01e6\n',
-  '\n\u0003\n\u0003\n\u0005\n\u01ea\n\n\u0003\n\u0005\n\u01ed\n\n\u0003',
-  '\n\u0005\n\u01f0\n\n\u0003\u000b\u0003\u000b\u0003\f\u0005\f\u01f5\n',
-  '\f\u0003\f\u0003\f\u0005\f\u01f9\n\f\u0003\r\u0003\r\u0003\r\u0007\r',
-  '\u01fe\n\r\f\r\u000e\r\u0201\u000b\r\u0003\u000e\u0003\u000e\u0003\u000e',
-  '\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000f',
-  '\u0003\u000f\u0003\u0010\u0003\u0010\u0003\u0010\u0007\u0010\u0210\n',
-  '\u0010\f\u0010\u000e\u0010\u0213\u000b\u0010\u0003\u0011\u0003\u0011',
-  '\u0003\u0012\u0003\u0012\u0003\u0012\u0003\u0012\u0003\u0012\u0003\u0013',
-  '\u0003\u0013\u0003\u0014\u0003\u0014\u0003\u0014\u0003\u0015\u0003\u0015',
-  '\u0003\u0015\u0003\u0016\u0003\u0016\u0003\u0016\u0007\u0016\u0227\n',
-  '\u0016\f\u0016\u000e\u0016\u022a\u000b\u0016\u0003\u0017\u0003\u0017',
-  '\u0003\u0017\u0003\u0017\u0003\u0017\u0005\u0017\u0231\n\u0017\u0005',
-  '\u0017\u0233\n\u0017\u0003\u0018\u0003\u0018\u0005\u0018\u0237\n\u0018',
-  '\u0003\u0018\u0007\u0018\u023a\n\u0018\f\u0018\u000e\u0018\u023d\u000b',
-  '\u0018\u0003\u0019\u0006\u0019\u0240\n\u0019\r\u0019\u000e\u0019\u0241',
-  '\u0003\u001a\u0003\u001a\u0003\u001b\u0003\u001b\u0005\u001b\u0248\n',
-  '\u001b\u0003\u001b\u0003\u001b\u0005\u001b\u024c\n\u001b\u0003\u001b',
-  '\u0003\u001b\u0005\u001b\u0250\n\u001b\u0003\u001b\u0003\u001b\u0005',
-  '\u001b\u0254\n\u001b\u0007\u001b\u0256\n\u001b\f\u001b\u000e\u001b\u0259',
-  '\u000b\u001b\u0003\u001b\u0003\u001b\u0003\u001b\u0003\u001b\u0005\u001b',
-  '\u025f\n\u001b\u0003\u001b\u0005\u001b\u0262\n\u001b\u0003\u001c\u0003',
-  '\u001c\u0005\u001c\u0266\n\u001c\u0003\u001c\u0003\u001c\u0005\u001c',
-  '\u026a\n\u001c\u0003\u001c\u0003\u001c\u0003\u001d\u0003\u001d\u0005',
-  '\u001d\u0270\n\u001d\u0003\u001d\u0003\u001d\u0005\u001d\u0274\n\u001d',
-  '\u0003\u001d\u0003\u001d\u0005\u001d\u0278\n\u001d\u0003\u001d\u0003',
-  '\u001d\u0005\u001d\u027c\n\u001d\u0007\u001d\u027e\n\u001d\f\u001d\u000e',
-  '\u001d\u0281\u000b\u001d\u0003\u001d\u0003\u001d\u0003\u001d\u0003\u001d',
-  '\u0005\u001d\u0287\n\u001d\u0003\u001d\u0005\u001d\u028a\n\u001d\u0003',
-  '\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0005',
-  '\u001e\u0292\n\u001e\u0003\u001f\u0003\u001f\u0003\u001f\u0003\u001f',
-  '\u0003\u001f\u0003\u001f\u0003\u001f\u0005\u001f\u029b\n\u001f\u0003',
-  ' \u0003 \u0003 \u0005 \u02a0\n \u0006 \u02a2\n \r \u000e \u02a3\u0003',
-  ' \u0005 \u02a7\n \u0003!\u0003!\u0003!\u0007!\u02ac\n!\f!\u000e!\u02af',
-  '\u000b!\u0003"\u0003"\u0003"\u0003#\u0003#\u0005#\u02b6\n#\u0007',
-  '#\u02b8\n#\f#\u000e#\u02bb\u000b#\u0003$\u0003$\u0003$\u0005$\u02c0',
-  '\n$\u0003%\u0003%\u0003%\u0005%\u02c5\n%\u0003%\u0003%\u0007%\u02c9',
-  "\n%\f%\u000e%\u02cc\u000b%\u0003&\u0003&\u0003'\u0003'\u0003(\u0003",
-  '(\u0003)\u0003)\u0005)\u02d6\n)\u0003)\u0003)\u0005)\u02da\n)\u0003',
-  ')\u0003)\u0003*\u0003*\u0005*\u02e0\n*\u0003+\u0003+\u0005+\u02e4\n',
-  '+\u0003,\u0003,\u0005,\u02e8\n,\u0003,\u0007,\u02eb\n,\f,\u000e,\u02ee',
-  '\u000b,\u0003-\u0003-\u0005-\u02f2\n-\u0003-\u0003-\u0003.\u0003.\u0005',
-  '.\u02f8\n.\u0003.\u0007.\u02fb\n.\f.\u000e.\u02fe\u000b.\u0003/\u0003',
-  '/\u0003/\u0003/\u0003/\u0003/\u0003/\u0005/\u0307\n/\u00030\u00030\u0005',
-  '0\u030b\n0\u00030\u00070\u030e\n0\f0\u000e0\u0311\u000b0\u00031\u0003',
-  '1\u00031\u00031\u00051\u0317\n1\u00031\u00031\u00031\u00051\u031c\n',
-  '1\u00031\u00051\u031f\n1\u00032\u00032\u00032\u00032\u00032\u00032\u0003',
-  '2\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00052\u032f\n2\u0003',
-  '3\u00033\u00033\u00033\u00033\u00033\u00033\u00033\u00033\u00033\u0005',
-  '3\u033b\n3\u00034\u00034\u00034\u00034\u00035\u00035\u00035\u00035\u0003',
-  '6\u00036\u00036\u00036\u00037\u00037\u00037\u00037\u00038\u00038\u0003',
-  '8\u00038\u00039\u00039\u00039\u00039\u0003:\u0003:\u0003:\u0003:\u0003',
-  ';\u0003;\u0003;\u0003;\u0003<\u0003<\u0003<\u0003<\u0003=\u0003=\u0003',
-  '=\u0003=\u0003>\u0003>\u0003>\u0003>\u0005>\u0369\n>\u0003>\u0003>\u0005',
-  '>\u036d\n>\u0003>\u0003>\u0005>\u0371\n>\u0003>\u0003>\u0005>\u0375',
-  '\n>\u0003>\u0003>\u0003?\u0003?\u0003?\u0003?\u0005?\u037d\n?\u0003',
-  '?\u0003?\u0005?\u0381\n?\u0003?\u0003?\u0003?\u0005?\u0386\n?\u0003',
-  '?\u0003?\u0005?\u038a\n?\u0003?\u0003?\u0003?\u0003?\u0003?\u0003?\u0003',
-  '?\u0003?\u0003@\u0003@\u0003@\u0003@\u0005@\u0398\n@\u0003@\u0003@\u0005',
-  '@\u039c\n@\u0003@\u0003@\u0003@\u0005@\u03a1\n@\u0003@\u0003@\u0005',
-  '@\u03a5\n@\u0003@\u0003@\u0003@\u0003@\u0005@\u03ab\n@\u0003@\u0003',
-  '@\u0005@\u03af\n@\u0003@\u0003@\u0003@\u0003@\u0003@\u0003@\u0003@\u0003',
-  '@\u0003A\u0003A\u0003A\u0003A\u0005A\u03bd\nA\u0003A\u0003A\u0003A\u0003',
-  'A\u0003A\u0005A\u03c4\nA\u0003A\u0003A\u0003A\u0003A\u0005A\u03ca\n',
-  'A\u0003A\u0003A\u0003A\u0003A\u0003B\u0003B\u0003B\u0003B\u0005B\u03d4',
-  '\nB\u0003B\u0003B\u0005B\u03d8\nB\u0003B\u0003B\u0003B\u0003B\u0005',
-  'B\u03de\nB\u0003B\u0003B\u0003B\u0003B\u0003C\u0003C\u0005C\u03e6\n',
-  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0005',
-  'C\u03f1\nC\u0003C\u0003C\u0003C\u0003C\u0005C\u03f7\nC\u0003C\u0003',
-  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0005C\u0403',
-  '\nC\u0003C\u0003C\u0003C\u0003C\u0005C\u0409\nC\u0003C\u0003C\u0003',
-  'C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0003C\u0005C\u0415\nC\u0003',
-  'C\u0003C\u0005C\u0419\nC\u0003D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003',
-  'D\u0003D\u0005D\u0423\nD\u0003D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003',
-  'D\u0003D\u0003D\u0003D\u0003D\u0005D\u0430\nD\u0003E\u0003E\u0005E\u0434',
-  '\nE\u0003E\u0003E\u0005E\u0438\nE\u0003E\u0003E\u0007E\u043c\nE\fE\u000e',
-  'E\u043f\u000bE\u0003E\u0005E\u0442\nE\u0003E\u0005E\u0445\nE\u0003F',
-  '\u0003F\u0005F\u0449\nF\u0003F\u0003F\u0003F\u0003F\u0003F\u0003F\u0003',
-  'G\u0003G\u0005G\u0453\nG\u0003G\u0003G\u0003G\u0007G\u0458\nG\fG\u000e',
-  'G\u045b\u000bG\u0003H\u0003H\u0003H\u0003H\u0003H\u0003H\u0003H\u0003',
-  'H\u0003H\u0003H\u0005H\u0467\nH\u0003I\u0003I\u0005I\u046b\nI\u0003',
-  'I\u0003I\u0003J\u0003J\u0003J\u0003J\u0005J\u0473\nJ\u0003J\u0003J\u0003',
-  'K\u0003K\u0005K\u0479\nK\u0003K\u0003K\u0005K\u047d\nK\u0003K\u0003',
-  'K\u0005K\u0481\nK\u0003K\u0007K\u0484\nK\fK\u000eK\u0487\u000bK\u0003',
-  'L\u0003L\u0005L\u048b\nL\u0003L\u0003L\u0005L\u048f\nL\u0003L\u0003',
-  'L\u0003L\u0003L\u0005L\u0495\nL\u0003L\u0003L\u0005L\u0499\nL\u0003',
-  'L\u0003L\u0003L\u0003L\u0005L\u049f\nL\u0003L\u0003L\u0005L\u04a3\n',
-  'L\u0003L\u0003L\u0003L\u0003L\u0005L\u04a9\nL\u0003L\u0003L\u0005L\u04ad',
-  '\nL\u0003M\u0003M\u0005M\u04b1\nM\u0003M\u0003M\u0005M\u04b5\nM\u0003',
-  'M\u0003M\u0005M\u04b9\nM\u0003M\u0003M\u0005M\u04bd\nM\u0003M\u0007',
-  'M\u04c0\nM\fM\u000eM\u04c3\u000bM\u0003N\u0003N\u0003N\u0003N\u0005',
-  'N\u04c9\nN\u0003N\u0003N\u0005N\u04cd\nN\u0003N\u0007N\u04d0\nN\fN\u000e',
-  'N\u04d3\u000bN\u0003O\u0003O\u0003O\u0003O\u0005O\u04d9\nO\u0003P\u0003',
-  'P\u0005P\u04dd\nP\u0003P\u0003P\u0005P\u04e1\nP\u0003P\u0003P\u0003',
-  'P\u0003P\u0003P\u0003P\u0005P\u04e9\nP\u0003P\u0003P\u0003P\u0006P\u04ee',
-  '\nP\rP\u000eP\u04ef\u0003P\u0005P\u04f3\nP\u0003P\u0003P\u0003Q\u0003',
-  'Q\u0005Q\u04f9\nQ\u0003Q\u0005Q\u04fc\nQ\u0003Q\u0003Q\u0003Q\u0005',
-  'Q\u0501\nQ\u0003Q\u0005Q\u0504\nQ\u0003R\u0003R\u0005R\u0508\nR\u0003',
-  'R\u0005R\u050b\nR\u0003R\u0005R\u050e\nR\u0003R\u0003R\u0003S\u0003',
-  'S\u0003S\u0005S\u0515\nS\u0003S\u0003S\u0005S\u0519\nS\u0003S\u0003',
-  'S\u0005S\u051d\nS\u0003T\u0003T\u0005T\u0521\nT\u0003T\u0003T\u0005',
-  'T\u0525\nT\u0003T\u0007T\u0528\nT\fT\u000eT\u052b\u000bT\u0003T\u0003',
-  'T\u0005T\u052f\nT\u0003T\u0003T\u0005T\u0533\nT\u0003T\u0007T\u0536',
-  '\nT\fT\u000eT\u0539\u000bT\u0003T\u0003T\u0005T\u053d\nT\u0003T\u0005',
-  'T\u0540\nT\u0005T\u0542\nT\u0003U\u0003U\u0003U\u0003U\u0003U\u0003',
-  'U\u0003U\u0005U\u054b\nU\u0003V\u0003V\u0003V\u0003V\u0005V\u0551\n',
-  'V\u0003V\u0005V\u0554\nV\u0003W\u0003W\u0005W\u0558\nW\u0003W\u0005',
-  'W\u055b\nW\u0003X\u0003X\u0003X\u0003Y\u0003Y\u0005Y\u0562\nY\u0003',
-  'Y\u0005Y\u0565\nY\u0003Y\u0005Y\u0568\nY\u0003Y\u0003Y\u0005Y\u056c',
-  '\nY\u0003Y\u0007Y\u056f\nY\fY\u000eY\u0572\u000bY\u0003Y\u0005Y\u0575',
-  '\nY\u0003Y\u0003Y\u0003Z\u0003Z\u0003Z\u0003Z\u0005Z\u057d\nZ\u0003',
-  'Z\u0003Z\u0005Z\u0581\nZ\u0003Z\u0007Z\u0584\nZ\fZ\u000eZ\u0587\u000b',
-  'Z\u0003Z\u0003Z\u0005Z\u058b\nZ\u0003[\u0003[\u0005[\u058f\n[\u0003',
-  '\\\u0003\\\u0003\\\u0003\\\u0003\\\u0003\\\u0003]\u0003]\u0003^\u0003',
-  '^\u0003_\u0003_\u0003_\u0003_\u0003_\u0003_\u0005_\u05a1\n_\u0003_\u0003',
-  '_\u0005_\u05a5\n_\u0003_\u0007_\u05a8\n_\f_\u000e_\u05ab\u000b_\u0003',
-  '`\u0003`\u0003`\u0003`\u0003a\u0003a\u0003a\u0003a\u0003b\u0003b\u0005',
-  'b\u05b7\nb\u0003b\u0003b\u0005b\u05bb\nb\u0005b\u05bd\nb\u0003c\u0005',
-  'c\u05c0\nc\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0005c\u05c9',
-  '\nc\u0003c\u0003c\u0005c\u05cd\nc\u0003c\u0003c\u0005c\u05d1\nc\u0003',
-  'c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0005',
-  'c\u05dd\nc\u0003c\u0003c\u0005c\u05e1\nc\u0003c\u0007c\u05e4\nc\fc\u000e',
-  'c\u05e7\u000bc\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0005',
-  'c\u05f0\nc\u0003d\u0003d\u0003d\u0003d\u0005d\u05f6\nd\u0003d\u0003',
-  'd\u0005d\u05fa\nd\u0003d\u0007d\u05fd\nd\fd\u000ed\u0600\u000bd\u0003',
-  'd\u0005d\u0603\nd\u0003e\u0003e\u0005e\u0607\ne\u0003e\u0003e\u0005',
-  'e\u060b\ne\u0003e\u0003e\u0003f\u0003f\u0005f\u0611\nf\u0003g\u0003',
-  'g\u0005g\u0615\ng\u0003g\u0003g\u0003g\u0005g\u061a\ng\u0003h\u0003',
-  'h\u0003h\u0003h\u0005h\u0620\nh\u0003i\u0003i\u0003i\u0003i\u0003i\u0003',
-  'i\u0003i\u0005i\u0629\ni\u0003i\u0003i\u0003j\u0003j\u0003j\u0003j\u0003',
-  'j\u0005j\u0632\nj\u0003j\u0003j\u0003k\u0003k\u0003k\u0003k\u0005k\u063a',
-  '\nk\u0003k\u0003k\u0003l\u0003l\u0005l\u0640\nl\u0003l\u0003l\u0005',
-  'l\u0644\nl\u0003l\u0007l\u0647\nl\fl\u000el\u064a\u000bl\u0003m\u0003',
-  'm\u0003m\u0003m\u0003n\u0003n\u0005n\u0652\nn\u0003n\u0003n\u0005n\u0656',
-  '\nn\u0003n\u0007n\u0659\nn\fn\u000en\u065c\u000bn\u0003o\u0003o\u0005',
-  'o\u0660\no\u0003o\u0003o\u0005o\u0664\no\u0003o\u0003o\u0003o\u0005',
-  'o\u0669\no\u0003p\u0003p\u0005p\u066d\np\u0003q\u0003q\u0005q\u0671',
-  '\nq\u0003q\u0007q\u0674\nq\fq\u000eq\u0677\u000bq\u0003q\u0003q\u0003',
-  'q\u0003q\u0005q\u067d\nq\u0003r\u0003r\u0005r\u0681\nr\u0003r\u0003',
-  'r\u0005r\u0685\nr\u0005r\u0687\nr\u0003r\u0003r\u0005r\u068b\nr\u0005',
-  'r\u068d\nr\u0003r\u0003r\u0005r\u0691\nr\u0005r\u0693\nr\u0003r\u0003',
-  'r\u0003s\u0003s\u0005s\u0699\ns\u0003s\u0003s\u0003t\u0003t\u0005t\u069f',
-  '\nt\u0003t\u0005t\u06a2\nt\u0003t\u0005t\u06a5\nt\u0003t\u0003t\u0003',
-  'u\u0003u\u0005u\u06ab\nu\u0003u\u0003u\u0003u\u0005u\u06b0\nu\u0003',
-  'v\u0003v\u0005v\u06b4\nv\u0003v\u0003v\u0003v\u0005v\u06b9\nv\u0003',
-  'w\u0003w\u0005w\u06bd\nw\u0003w\u0003w\u0005w\u06c1\nw\u0005w\u06c3',
-  '\nw\u0003w\u0003w\u0005w\u06c7\nw\u0005w\u06c9\nw\u0003w\u0005w\u06cc',
-  '\nw\u0003w\u0003w\u0005w\u06d0\nw\u0005w\u06d2\nw\u0003w\u0003w\u0003',
-  'x\u0003x\u0005x\u06d8\nx\u0003y\u0003y\u0005y\u06dc\ny\u0003y\u0003',
-  'y\u0003z\u0003z\u0005z\u06e2\nz\u0003z\u0003z\u0007z\u06e6\nz\fz\u000e',
-  'z\u06e9\u000bz\u0003{\u0003{\u0003{\u0003|\u0005|\u06ef\n|\u0003|\u0003',
-  '|\u0003}\u0003}\u0005}\u06f5\n}\u0003}\u0007}\u06f8\n}\f}\u000e}\u06fb',
-  '\u000b}\u0003~\u0003~\u0003~\u0003\u007f\u0003\u007f\u0005\u007f\u0702',
-  '\n\u007f\u0003\u007f\u0003\u007f\u0005\u007f\u0706\n\u007f\u0005\u007f',
-  '\u0708\n\u007f\u0003\u007f\u0003\u007f\u0005\u007f\u070c\n\u007f\u0003',
-  '\u007f\u0003\u007f\u0005\u007f\u0710\n\u007f\u0005\u007f\u0712\n\u007f',
-  '\u0005\u007f\u0714\n\u007f\u0003\u0080\u0003\u0080\u0003\u0081\u0003',
-  '\u0081\u0003\u0082\u0003\u0082\u0003\u0083\u0003\u0083\u0003\u0083\u0003',
-  '\u0083\u0003\u0083\u0007\u0083\u0721\n\u0083\f\u0083\u000e\u0083\u0724',
-  '\u000b\u0083\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084',
-  '\u0007\u0084\u072b\n\u0084\f\u0084\u000e\u0084\u072e\u000b\u0084\u0003',
-  '\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0007\u0085\u0735',
-  '\n\u0085\f\u0085\u000e\u0085\u0738\u000b\u0085\u0003\u0086\u0003\u0086',
-  '\u0005\u0086\u073c\n\u0086\u0007\u0086\u073e\n\u0086\f\u0086\u000e\u0086',
-  '\u0741\u000b\u0086\u0003\u0086\u0003\u0086\u0003\u0087\u0003\u0087\u0005',
-  '\u0087\u0747\n\u0087\u0003\u0087\u0007\u0087\u074a\n\u0087\f\u0087\u000e',
-  '\u0087\u074d\u000b\u0087\u0003\u0088\u0003\u0088\u0005\u0088\u0751\n',
-  '\u0088\u0003\u0088\u0003\u0088\u0005\u0088\u0755\n\u0088\u0003\u0088',
-  '\u0003\u0088\u0005\u0088\u0759\n\u0088\u0003\u0088\u0003\u0088\u0005',
-  '\u0088\u075d\n\u0088\u0003\u0088\u0007\u0088\u0760\n\u0088\f\u0088\u000e',
-  '\u0088\u0763\u000b\u0088\u0003\u0089\u0003\u0089\u0005\u0089\u0767\n',
-  '\u0089\u0003\u0089\u0003\u0089\u0005\u0089\u076b\n\u0089\u0003\u0089',
-  '\u0003\u0089\u0005\u0089\u076f\n\u0089\u0003\u0089\u0003\u0089\u0005',
-  '\u0089\u0773\n\u0089\u0003\u0089\u0003\u0089\u0005\u0089\u0777\n\u0089',
-  '\u0003\u0089\u0003\u0089\u0005\u0089\u077b\n\u0089\u0003\u0089\u0007',
-  '\u0089\u077e\n\u0089\f\u0089\u000e\u0089\u0781\u000b\u0089\u0003\u008a',
-  '\u0003\u008a\u0005\u008a\u0785\n\u008a\u0003\u008a\u0003\u008a\u0005',
-  '\u008a\u0789\n\u008a\u0003\u008a\u0007\u008a\u078c\n\u008a\f\u008a\u000e',
-  '\u008a\u078f\u000b\u008a\u0003\u008b\u0003\u008b\u0005\u008b\u0793\n',
-  '\u008b\u0007\u008b\u0795\n\u008b\f\u008b\u000e\u008b\u0798\u000b\u008b',
-  '\u0003\u008b\u0003\u008b\u0003\u008c\u0003\u008c\u0005\u008c\u079e\n',
-  '\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0005',
-  '\u008c\u07a5\n\u008c\u0003\u008c\u0003\u008c\u0005\u008c\u07a9\n\u008c',
-  '\u0003\u008c\u0003\u008c\u0005\u008c\u07ad\n\u008c\u0003\u008c\u0003',
-  '\u008c\u0005\u008c\u07b1\n\u008c\u0003\u008c\u0003\u008c\u0003\u008c',
-  '\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c',
-  '\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0005\u008c\u07c0\n',
-  '\u008c\u0003\u008c\u0005\u008c\u07c3\n\u008c\u0003\u008c\u0003\u008c',
-  '\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c',
-  '\u0003\u008c\u0003\u008c\u0003\u008c\u0007\u008c\u07d0\n\u008c\f\u008c',
-  '\u000e\u008c\u07d3\u000b\u008c\u0003\u008d\u0003\u008d\u0005\u008d\u07d7',
-  '\n\u008d\u0003\u008d\u0003\u008d\u0005\u008d\u07db\n\u008d\u0007\u008d',
-  '\u07dd\n\u008d\f\u008d\u000e\u008d\u07e0\u000b\u008d\u0003\u008e\u0003',
-  '\u008e\u0005\u008e\u07e4\n\u008e\u0003\u008e\u0003\u008e\u0005\u008e',
-  '\u07e8\n\u008e\u0003\u008e\u0003\u008e\u0005\u008e\u07ec\n\u008e\u0003',
-  '\u008e\u0003\u008e\u0003\u008f\u0003\u008f\u0003\u0090\u0003\u0090\u0005',
-  '\u0090\u07f4\n\u0090\u0003\u0090\u0003\u0090\u0005\u0090\u07f8\n\u0090',
-  '\u0003\u0090\u0003\u0090\u0005\u0090\u07fc\n\u0090\u0003\u0090\u0003',
-  '\u0090\u0003\u0091\u0003\u0091\u0003\u0092\u0003\u0092\u0005\u0092\u0804',
-  '\n\u0092\u0003\u0092\u0003\u0092\u0005\u0092\u0808\n\u0092\u0003\u0092',
-  '\u0003\u0092\u0005\u0092\u080c\n\u0092\u0003\u0092\u0003\u0092\u0003',
-  '\u0093\u0003\u0093\u0003\u0094\u0003\u0094\u0005\u0094\u0814\n\u0094',
-  '\u0003\u0094\u0003\u0094\u0005\u0094\u0818\n\u0094\u0003\u0094\u0003',
-  '\u0094\u0005\u0094\u081c\n\u0094\u0003\u0094\u0003\u0094\u0003\u0095',
-  '\u0003\u0095\u0003\u0096\u0003\u0096\u0005\u0096\u0824\n\u0096\u0003',
-  '\u0096\u0003\u0096\u0005\u0096\u0828\n\u0096\u0003\u0096\u0003\u0096',
-  '\u0005\u0096\u082c\n\u0096\u0003\u0096\u0003\u0096\u0003\u0097\u0003',
-  '\u0097\u0003\u0098\u0003\u0098\u0005\u0098\u0834\n\u0098\u0003\u0098',
-  '\u0003\u0098\u0005\u0098\u0838\n\u0098\u0003\u0098\u0003\u0098\u0005',
-  '\u0098\u083c\n\u0098\u0003\u0098\u0003\u0098\u0003\u0099\u0003\u0099',
-  '\u0003\u009a\u0003\u009a\u0005\u009a\u0844\n\u009a\u0003\u009a\u0003',
-  '\u009a\u0005\u009a\u0848\n\u009a\u0003\u009a\u0003\u009a\u0005\u009a',
-  '\u084c\n\u009a\u0003\u009a\u0003\u009a\u0005\u009a\u0850\n\u009a\u0003',
-  '\u009a\u0005\u009a\u0853\n\u009a\u0003\u009a\u0005\u009a\u0856\n\u009a',
-  '\u0003\u009a\u0003\u009a\u0003\u009b\u0003\u009b\u0003\u009c\u0003\u009c',
-  '\u0005\u009c\u085e\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c\u0862',
-  '\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c\u0866\n\u009c\u0003\u009c',
-  '\u0003\u009c\u0005\u009c\u086a\n\u009c\u0003\u009c\u0003\u009c\u0005',
-  '\u009c\u086e\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c\u0872\n\u009c',
-  '\u0003\u009c\u0003\u009c\u0005\u009c\u0876\n\u009c\u0003\u009c\u0003',
-  '\u009c\u0005\u009c\u087a\n\u009c\u0003\u009c\u0003\u009c\u0005\u009c',
-  '\u087e\n\u009c\u0003\u009c\u0003\u009c\u0003\u009d\u0003\u009d\u0003',
-  '\u009e\u0003\u009e\u0005\u009e\u0886\n\u009e\u0003\u009e\u0003\u009e',
-  '\u0005\u009e\u088a\n\u009e\u0003\u009e\u0003\u009e\u0005\u009e\u088e',
-  '\n\u009e\u0003\u009e\u0003\u009e\u0003\u009e\u0003\u009e\u0005\u009e',
-  '\u0894\n\u009e\u0003\u009e\u0003\u009e\u0005\u009e\u0898\n\u009e\u0003',
-  '\u009e\u0003\u009e\u0005\u009e\u089c\n\u009e\u0003\u009e\u0003\u009e',
-  '\u0005\u009e\u08a0\n\u009e\u0003\u009f\u0003\u009f\u0003\u00a0\u0003',
-  '\u00a0\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0005',
-  '\u00a1\u08ab\n\u00a1\u0003\u00a1\u0003\u00a1\u0005\u00a1\u08af\n\u00a1',
-  '\u0003\u00a1\u0003\u00a1\u0005\u00a1\u08b3\n\u00a1\u0003\u00a1\u0003',
-  '\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003',
-  '\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003',
-  '\u00a1\u0003\u00a1\u0003\u00a1\u0005\u00a1\u08c5\n\u00a1\u0003\u00a2',
-  '\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2',
-  '\u0005\u00a2\u08ce\n\u00a2\u0003\u00a3\u0003\u00a3\u0003\u00a4\u0003',
-  '\u00a4\u0003\u00a5\u0003\u00a5\u0005\u00a5\u08d6\n\u00a5\u0003\u00a5',
-  '\u0003\u00a5\u0005\u00a5\u08da\n\u00a5\u0003\u00a5\u0003\u00a5\u0005',
-  '\u00a5\u08de\n\u00a5\u0003\u00a5\u0003\u00a5\u0005\u00a5\u08e2\n\u00a5',
-  '\u0007\u00a5\u08e4\n\u00a5\f\u00a5\u000e\u00a5\u08e7\u000b\u00a5\u0005',
-  '\u00a5\u08e9\n\u00a5\u0003\u00a5\u0003\u00a5\u0003\u00a6\u0003\u00a6',
-  '\u0005\u00a6\u08ef\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005',
-  '\u00a6\u08f4\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6',
-  '\u08f9\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u08fe',
-  '\n\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u0903\n\u00a6',
-  '\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u0908\n\u00a6\u0003',
-  '\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u090d\n\u00a6\u0003\u00a6',
-  '\u0005\u00a6\u0910\n\u00a6\u0003\u00a7\u0003\u00a7\u0005\u00a7\u0914',
-  '\n\u00a7\u0003\u00a7\u0003\u00a7\u0005\u00a7\u0918\n\u00a7\u0003\u00a7',
-  '\u0003\u00a7\u0003\u00a8\u0003\u00a8\u0005\u00a8\u091e\n\u00a8\u0003',
-  '\u00a8\u0006\u00a8\u0921\n\u00a8\r\u00a8\u000e\u00a8\u0922\u0003\u00a9',
-  '\u0003\u00a9\u0005\u00a9\u0927\n\u00a9\u0003\u00a9\u0005\u00a9\u092a',
-  '\n\u00a9\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa',
-  '\u0003\u00aa\u0003\u00ab\u0003\u00ab\u0005\u00ab\u0934\n\u00ab\u0003',
-  '\u00ab\u0003\u00ab\u0005\u00ab\u0938\n\u00ab\u0003\u00ab\u0003\u00ab',
-  '\u0005\u00ab\u093c\n\u00ab\u0005\u00ab\u093e\n\u00ab\u0003\u00ab\u0003',
-  '\u00ab\u0005\u00ab\u0942\n\u00ab\u0003\u00ab\u0003\u00ab\u0005\u00ab',
-  '\u0946\n\u00ab\u0003\u00ab\u0003\u00ab\u0005\u00ab\u094a\n\u00ab\u0007',
-  '\u00ab\u094c\n\u00ab\f\u00ab\u000e\u00ab\u094f\u000b\u00ab\u0005\u00ab',
-  '\u0951\n\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ac\u0003\u00ac\u0003',
-  '\u00ac\u0003\u00ad\u0003\u00ad\u0003\u00ae\u0003\u00ae\u0003\u00af\u0003',
-  '\u00af\u0005\u00af\u095e\n\u00af\u0003\u00af\u0003\u00af\u0005\u00af',
-  '\u0962\n\u00af\u0003\u00af\u0003\u00af\u0005\u00af\u0966\n\u00af\u0003',
-  '\u00af\u0005\u00af\u0969\n\u00af\u0003\u00af\u0005\u00af\u096c\n\u00af',
-  '\u0003\u00af\u0003\u00af\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0972\n',
-  '\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0976\n\u00b0\u0003\u00b0',
-  '\u0003\u00b0\u0005\u00b0\u097a\n\u00b0\u0005\u00b0\u097c\n\u00b0\u0003',
-  '\u00b0\u0003\u00b0\u0005\u00b0\u0980\n\u00b0\u0003\u00b0\u0003\u00b0',
-  '\u0005\u00b0\u0984\n\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0988',
-  '\n\u00b0\u0005\u00b0\u098a\n\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0',
-  '\u098e\n\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0\u0992\n\u00b0\u0003',
-  '\u00b0\u0003\u00b0\u0003\u00b1\u0003\u00b1\u0005\u00b1\u0998\n\u00b1',
-  '\u0003\u00b1\u0003\u00b1\u0003\u00b2\u0003\u00b2\u0005\u00b2\u099e\n',
-  '\u00b2\u0003\u00b2\u0006\u00b2\u09a1\n\u00b2\r\u00b2\u000e\u00b2\u09a2',
-  '\u0003\u00b2\u0003\u00b2\u0005\u00b2\u09a7\n\u00b2\u0003\u00b2\u0003',
-  '\u00b2\u0005\u00b2\u09ab\n\u00b2\u0003\u00b2\u0006\u00b2\u09ae\n\u00b2',
-  '\r\u00b2\u000e\u00b2\u09af\u0005\u00b2\u09b2\n\u00b2\u0003\u00b2\u0005',
-  '\u00b2\u09b5\n\u00b2\u0003\u00b2\u0003\u00b2\u0005\u00b2\u09b9\n\u00b2',
-  '\u0003\u00b2\u0005\u00b2\u09bc\n\u00b2\u0003\u00b2\u0005\u00b2\u09bf',
-  '\n\u00b2\u0003\u00b2\u0003\u00b2\u0003\u00b3\u0003\u00b3\u0005\u00b3',
-  '\u09c5\n\u00b3\u0003\u00b3\u0003\u00b3\u0005\u00b3\u09c9\n\u00b3\u0003',
-  '\u00b3\u0003\u00b3\u0005\u00b3\u09cd\n\u00b3\u0003\u00b3\u0003\u00b3',
-  '\u0003\u00b4\u0003\u00b4\u0003\u00b5\u0003\u00b5\u0005\u00b5\u09d5\n',
-  '\u00b5\u0003\u00b6\u0003\u00b6\u0005\u00b6\u09d9\n\u00b6\u0003\u00b6',
-  '\u0003\u00b6\u0005\u00b6\u09dd\n\u00b6\u0003\u00b6\u0003\u00b6\u0005',
-  '\u00b6\u09e1\n\u00b6\u0003\u00b6\u0003\u00b6\u0005\u00b6\u09e5\n\u00b6',
-  '\u0007\u00b6\u09e7\n\u00b6\f\u00b6\u000e\u00b6\u09ea\u000b\u00b6\u0005',
-  '\u00b6\u09ec\n\u00b6\u0003\u00b6\u0003\u00b6\u0003\u00b7\u0003\u00b7',
-  '\u0005\u00b7\u09f2\n\u00b7\u0003\u00b7\u0003\u00b7\u0005\u00b7\u09f6',
-  '\n\u00b7\u0003\u00b7\u0005\u00b7\u09f9\n\u00b7\u0003\u00b7\u0005\u00b7',
-  '\u09fc\n\u00b7\u0003\u00b7\u0003\u00b7\u0005\u00b7\u0a00\n\u00b7\u0003',
-  '\u00b7\u0007\u00b7\u0a03\n\u00b7\f\u00b7\u000e\u00b7\u0a06\u000b\u00b7',
-  '\u0003\u00b7\u0005\u00b7\u0a09\n\u00b7\u0003\u00b7\u0003\u00b7\u0003',
-  '\u00b8\u0003\u00b8\u0003\u00b8\u0003\u00b8\u0005\u00b8\u0a11\n\u00b8',
-  '\u0003\u00b9\u0003\u00b9\u0005\u00b9\u0a15\n\u00b9\u0003\u00b9\u0003',
-  '\u00b9\u0005\u00b9\u0a19\n\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00ba',
-  '\u0003\u00ba\u0003\u00ba\u0003\u00bb\u0003\u00bb\u0003\u00bc\u0003\u00bc',
-  '\u0003\u00bc\u0003\u00bd\u0003\u00bd\u0005\u00bd\u0a27\n\u00bd\u0003',
-  '\u00be\u0003\u00be\u0005\u00be\u0a2b\n\u00be\u0003\u00be\u0003\u00be',
-  '\u0005\u00be\u0a2f\n\u00be\u0003\u00be\u0003\u00be\u0003\u00bf\u0003',
-  '\u00bf\u0003\u00bf\u0003\u00c0\u0003\u00c0\u0005\u00c0\u0a38\n\u00c0',
-  '\u0003\u00c1\u0003\u00c1\u0005\u00c1\u0a3c\n\u00c1\u0003\u00c1\u0003',
-  '\u00c1\u0005\u00c1\u0a40\n\u00c1\u0003\u00c1\u0007\u00c1\u0a43\n\u00c1',
-  '\f\u00c1\u000e\u00c1\u0a46\u000b\u00c1\u0003\u00c2\u0003\u00c2\u0005',
-  '\u00c2\u0a4a\n\u00c2\u0003\u00c2\u0006\u00c2\u0a4d\n\u00c2\r\u00c2\u000e',
-  '\u00c2\u0a4e\u0003\u00c3\u0003\u00c3\u0005\u00c3\u0a53\n\u00c3\u0003',
-  '\u00c3\u0003\u00c3\u0005\u00c3\u0a57\n\u00c3\u0003\u00c3\u0007\u00c3',
-  '\u0a5a\n\u00c3\f\u00c3\u000e\u00c3\u0a5d\u000b\u00c3\u0003\u00c4\u0003',
-  '\u00c4\u0003\u00c5\u0003\u00c5\u0003\u00c6\u0003\u00c6\u0003\u00c7\u0003',
-  '\u00c7\u0003\u00c7\u0007\u00c7\u0a68\n\u00c7\f\u00c7\u000e\u00c7\u0a6b',
-  '\u000b\u00c7\u0003\u00c8\u0003\u00c8\u0003\u00c9\u0003\u00c9\u0003\u00ca',
-  '\u0003\u00ca\u0003\u00cb\u0003\u00cb\u0003\u00cb\u0003\u00cb\u0005\u00cb',
-  '\u0a77\n\u00cb\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u023b\u0002',
-  '\u00cd\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a',
-  '\u001c\u001e "$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080',
-  '\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098',
-  '\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0',
-  '\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8',
-  '\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0',
-  '\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8',
-  '\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110',
-  '\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128',
-  '\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140',
-  '\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158',
-  '\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170',
-  '\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188',
-  '\u018a\u018c\u018e\u0190\u0192\u0194\u0196\u0002\u000e\u0004\u0002\t',
-  '\t\u000f\u000f\u0003\u0002`c\u0003\u0002hi\u0004\u0002\u0005\u0005\u000f',
-  '\u000f\u0003\u0002{|\u0005\u0002uu\u0095\u0095\u0098\u0098\u0003\u0002',
-  '\u0089\u008b\u0003\u0002\u0093\u0094\u0004\u0002  %(\u0004\u0002!!)',
-  ',\u0004\u0002\u0005\u0005-7\u0003\u00028\u0085\u0002\u0ba5\u0002\u0198',
-  '\u0003\u0002\u0002\u0002\u0004\u01a6\u0003\u0002\u0002\u0002\u0006\u01af',
-  '\u0003\u0002\u0002\u0002\b\u01b4\u0003\u0002\u0002\u0002\n\u01bd\u0003',
-  '\u0002\u0002\u0002\f\u01cf\u0003\u0002\u0002\u0002\u000e\u01d1\u0003',
-  '\u0002\u0002\u0002\u0010\u01db\u0003\u0002\u0002\u0002\u0012\u01dd\u0003',
-  '\u0002\u0002\u0002\u0014\u01f1\u0003\u0002\u0002\u0002\u0016\u01f4\u0003',
-  '\u0002\u0002\u0002\u0018\u01fa\u0003\u0002\u0002\u0002\u001a\u0202\u0003',
-  '\u0002\u0002\u0002\u001c\u020a\u0003\u0002\u0002\u0002\u001e\u020c\u0003',
-  '\u0002\u0002\u0002 \u0214\u0003\u0002\u0002\u0002"\u0216\u0003\u0002',
-  '\u0002\u0002$\u021b\u0003\u0002\u0002\u0002&\u021d\u0003\u0002\u0002',
-  '\u0002(\u0220\u0003\u0002\u0002\u0002*\u0223\u0003\u0002\u0002\u0002',
-  ',\u022b\u0003\u0002\u0002\u0002.\u0234\u0003\u0002\u0002\u00020\u023f',
-  '\u0003\u0002\u0002\u00022\u0243\u0003\u0002\u0002\u00024\u0261\u0003',
-  '\u0002\u0002\u00026\u0263\u0003\u0002\u0002\u00028\u0289\u0003\u0002',
-  '\u0002\u0002:\u0291\u0003\u0002\u0002\u0002<\u0293\u0003\u0002\u0002',
-  '\u0002>\u02a1\u0003\u0002\u0002\u0002@\u02a8\u0003\u0002\u0002\u0002',
-  'B\u02b0\u0003\u0002\u0002\u0002D\u02b9\u0003\u0002\u0002\u0002F\u02bf',
-  '\u0003\u0002\u0002\u0002H\u02c1\u0003\u0002\u0002\u0002J\u02cd\u0003',
-  '\u0002\u0002\u0002L\u02cf\u0003\u0002\u0002\u0002N\u02d1\u0003\u0002',
-  '\u0002\u0002P\u02d3\u0003\u0002\u0002\u0002R\u02df\u0003\u0002\u0002',
-  '\u0002T\u02e3\u0003\u0002\u0002\u0002V\u02e5\u0003\u0002\u0002\u0002',
-  'X\u02ef\u0003\u0002\u0002\u0002Z\u02f5\u0003\u0002\u0002\u0002\\\u02ff',
-  '\u0003\u0002\u0002\u0002^\u0308\u0003\u0002\u0002\u0002`\u031e\u0003',
-  '\u0002\u0002\u0002b\u032e\u0003\u0002\u0002\u0002d\u033a\u0003\u0002',
-  '\u0002\u0002f\u033c\u0003\u0002\u0002\u0002h\u0340\u0003\u0002\u0002',
-  '\u0002j\u0344\u0003\u0002\u0002\u0002l\u0348\u0003\u0002\u0002\u0002',
-  'n\u034c\u0003\u0002\u0002\u0002p\u0350\u0003\u0002\u0002\u0002r\u0354',
-  '\u0003\u0002\u0002\u0002t\u0358\u0003\u0002\u0002\u0002v\u035c\u0003',
-  '\u0002\u0002\u0002x\u0360\u0003\u0002\u0002\u0002z\u0364\u0003\u0002',
-  '\u0002\u0002|\u0378\u0003\u0002\u0002\u0002~\u0393\u0003\u0002\u0002',
-  '\u0002\u0080\u03b8\u0003\u0002\u0002\u0002\u0082\u03cf\u0003\u0002\u0002',
-  '\u0002\u0084\u0418\u0003\u0002\u0002\u0002\u0086\u041a\u0003\u0002\u0002',
-  '\u0002\u0088\u0433\u0003\u0002\u0002\u0002\u008a\u0446\u0003\u0002\u0002',
-  '\u0002\u008c\u0450\u0003\u0002\u0002\u0002\u008e\u0466\u0003\u0002\u0002',
-  '\u0002\u0090\u0468\u0003\u0002\u0002\u0002\u0092\u046e\u0003\u0002\u0002',
-  '\u0002\u0094\u0476\u0003\u0002\u0002\u0002\u0096\u04ac\u0003\u0002\u0002',
-  '\u0002\u0098\u04b0\u0003\u0002\u0002\u0002\u009a\u04c4\u0003\u0002\u0002',
-  '\u0002\u009c\u04d8\u0003\u0002\u0002\u0002\u009e\u04da\u0003\u0002\u0002',
-  '\u0002\u00a0\u04f6\u0003\u0002\u0002\u0002\u00a2\u0505\u0003\u0002\u0002',
-  '\u0002\u00a4\u0511\u0003\u0002\u0002\u0002\u00a6\u0541\u0003\u0002\u0002',
-  '\u0002\u00a8\u054a\u0003\u0002\u0002\u0002\u00aa\u054c\u0003\u0002\u0002',
-  '\u0002\u00ac\u0555\u0003\u0002\u0002\u0002\u00ae\u055c\u0003\u0002\u0002',
-  '\u0002\u00b0\u055f\u0003\u0002\u0002\u0002\u00b2\u0578\u0003\u0002\u0002',
-  '\u0002\u00b4\u058e\u0003\u0002\u0002\u0002\u00b6\u0590\u0003\u0002\u0002',
-  '\u0002\u00b8\u0596\u0003\u0002\u0002\u0002\u00ba\u0598\u0003\u0002\u0002',
-  '\u0002\u00bc\u059a\u0003\u0002\u0002\u0002\u00be\u05ac\u0003\u0002\u0002',
-  '\u0002\u00c0\u05b0\u0003\u0002\u0002\u0002\u00c2\u05b4\u0003\u0002\u0002',
-  '\u0002\u00c4\u05bf\u0003\u0002\u0002\u0002\u00c6\u05f1\u0003\u0002\u0002',
-  '\u0002\u00c8\u0604\u0003\u0002\u0002\u0002\u00ca\u0610\u0003\u0002\u0002',
-  '\u0002\u00cc\u0612\u0003\u0002\u0002\u0002\u00ce\u061b\u0003\u0002\u0002',
-  '\u0002\u00d0\u0621\u0003\u0002\u0002\u0002\u00d2\u062c\u0003\u0002\u0002',
-  '\u0002\u00d4\u0635\u0003\u0002\u0002\u0002\u00d6\u063d\u0003\u0002\u0002',
-  '\u0002\u00d8\u064b\u0003\u0002\u0002\u0002\u00da\u064f\u0003\u0002\u0002',
-  '\u0002\u00dc\u0668\u0003\u0002\u0002\u0002\u00de\u066c\u0003\u0002\u0002',
-  '\u0002\u00e0\u067c\u0003\u0002\u0002\u0002\u00e2\u067e\u0003\u0002\u0002',
-  '\u0002\u00e4\u0696\u0003\u0002\u0002\u0002\u00e6\u069c\u0003\u0002\u0002',
-  '\u0002\u00e8\u06af\u0003\u0002\u0002\u0002\u00ea\u06b8\u0003\u0002\u0002',
-  '\u0002\u00ec\u06ba\u0003\u0002\u0002\u0002\u00ee\u06d7\u0003\u0002\u0002',
-  '\u0002\u00f0\u06d9\u0003\u0002\u0002\u0002\u00f2\u06df\u0003\u0002\u0002',
-  '\u0002\u00f4\u06ea\u0003\u0002\u0002\u0002\u00f6\u06ee\u0003\u0002\u0002',
-  '\u0002\u00f8\u06f2\u0003\u0002\u0002\u0002\u00fa\u06fc\u0003\u0002\u0002',
-  '\u0002\u00fc\u06ff\u0003\u0002\u0002\u0002\u00fe\u0715\u0003\u0002\u0002',
-  '\u0002\u0100\u0717\u0003\u0002\u0002\u0002\u0102\u0719\u0003\u0002\u0002',
-  '\u0002\u0104\u071b\u0003\u0002\u0002\u0002\u0106\u0725\u0003\u0002\u0002',
-  '\u0002\u0108\u072f\u0003\u0002\u0002\u0002\u010a\u073f\u0003\u0002\u0002',
-  '\u0002\u010c\u0744\u0003\u0002\u0002\u0002\u010e\u074e\u0003\u0002\u0002',
-  '\u0002\u0110\u0764\u0003\u0002\u0002\u0002\u0112\u0782\u0003\u0002\u0002',
-  '\u0002\u0114\u0796\u0003\u0002\u0002\u0002\u0116\u079b\u0003\u0002\u0002',
-  '\u0002\u0118\u07d4\u0003\u0002\u0002\u0002\u011a\u07e1\u0003\u0002\u0002',
-  '\u0002\u011c\u07ef\u0003\u0002\u0002\u0002\u011e\u07f1\u0003\u0002\u0002',
-  '\u0002\u0120\u07ff\u0003\u0002\u0002\u0002\u0122\u0801\u0003\u0002\u0002',
-  '\u0002\u0124\u080f\u0003\u0002\u0002\u0002\u0126\u0811\u0003\u0002\u0002',
-  '\u0002\u0128\u081f\u0003\u0002\u0002\u0002\u012a\u0821\u0003\u0002\u0002',
-  '\u0002\u012c\u082f\u0003\u0002\u0002\u0002\u012e\u0831\u0003\u0002\u0002',
-  '\u0002\u0130\u083f\u0003\u0002\u0002\u0002\u0132\u0841\u0003\u0002\u0002',
-  '\u0002\u0134\u0859\u0003\u0002\u0002\u0002\u0136\u085b\u0003\u0002\u0002',
-  '\u0002\u0138\u0881\u0003\u0002\u0002\u0002\u013a\u089f\u0003\u0002\u0002',
-  '\u0002\u013c\u08a1\u0003\u0002\u0002\u0002\u013e\u08a3\u0003\u0002\u0002',
-  '\u0002\u0140\u08c4\u0003\u0002\u0002\u0002\u0142\u08cd\u0003\u0002\u0002',
-  '\u0002\u0144\u08cf\u0003\u0002\u0002\u0002\u0146\u08d1\u0003\u0002\u0002',
-  '\u0002\u0148\u08d3\u0003\u0002\u0002\u0002\u014a\u090f\u0003\u0002\u0002',
-  '\u0002\u014c\u0911\u0003\u0002\u0002\u0002\u014e\u091b\u0003\u0002\u0002',
-  '\u0002\u0150\u0924\u0003\u0002\u0002\u0002\u0152\u092b\u0003\u0002\u0002',
-  '\u0002\u0154\u0931\u0003\u0002\u0002\u0002\u0156\u0954\u0003\u0002\u0002',
-  '\u0002\u0158\u0957\u0003\u0002\u0002\u0002\u015a\u0959\u0003\u0002\u0002',
-  '\u0002\u015c\u095b\u0003\u0002\u0002\u0002\u015e\u096f\u0003\u0002\u0002',
-  '\u0002\u0160\u0995\u0003\u0002\u0002\u0002\u0162\u09b1\u0003\u0002\u0002',
-  '\u0002\u0164\u09c2\u0003\u0002\u0002\u0002\u0166\u09d0\u0003\u0002\u0002',
-  '\u0002\u0168\u09d4\u0003\u0002\u0002\u0002\u016a\u09d6\u0003\u0002\u0002',
-  '\u0002\u016c\u09ef\u0003\u0002\u0002\u0002\u016e\u0a10\u0003\u0002\u0002',
-  '\u0002\u0170\u0a12\u0003\u0002\u0002\u0002\u0172\u0a1c\u0003\u0002\u0002',
-  '\u0002\u0174\u0a1f\u0003\u0002\u0002\u0002\u0176\u0a21\u0003\u0002\u0002',
-  '\u0002\u0178\u0a26\u0003\u0002\u0002\u0002\u017a\u0a28\u0003\u0002\u0002',
-  '\u0002\u017c\u0a32\u0003\u0002\u0002\u0002\u017e\u0a37\u0003\u0002\u0002',
-  '\u0002\u0180\u0a39\u0003\u0002\u0002\u0002\u0182\u0a47\u0003\u0002\u0002',
-  '\u0002\u0184\u0a50\u0003\u0002\u0002\u0002\u0186\u0a5e\u0003\u0002\u0002',
-  '\u0002\u0188\u0a60\u0003\u0002\u0002\u0002\u018a\u0a62\u0003\u0002\u0002',
-  '\u0002\u018c\u0a69\u0003\u0002\u0002\u0002\u018e\u0a6c\u0003\u0002\u0002',
-  '\u0002\u0190\u0a6e\u0003\u0002\u0002\u0002\u0192\u0a70\u0003\u0002\u0002',
-  '\u0002\u0194\u0a76\u0003\u0002\u0002\u0002\u0196\u0a78\u0003\u0002\u0002',
-  '\u0002\u0198\u019d\u0005\u0004\u0003\u0002\u0199\u019a\u0007\u0003\u0002',
-  '\u0002\u019a\u019c\u0005\u0004\u0003\u0002\u019b\u0199\u0003\u0002\u0002',
-  '\u0002\u019c\u019f\u0003\u0002\u0002\u0002\u019d\u019b\u0003\u0002\u0002',
-  '\u0002\u019d\u019e\u0003\u0002\u0002\u0002\u019e\u01a1\u0003\u0002\u0002',
-  '\u0002\u019f\u019d\u0003\u0002\u0002\u0002\u01a0\u01a2\u0007\u0003\u0002',
-  '\u0002\u01a1\u01a0\u0003\u0002\u0002\u0002\u01a1\u01a2\u0003\u0002\u0002',
-  '\u0002\u01a2\u01a3\u0003\u0002\u0002\u0002\u01a3\u01a4\u0007\u0002\u0002',
-  '\u0003\u01a4\u0003\u0003\u0002\u0002\u0002\u01a5\u01a7\u0007\u0099\u0002',
-  '\u0002\u01a6\u01a5\u0003\u0002\u0002\u0002\u01a6\u01a7\u0003\u0002\u0002',
-  '\u0002\u01a7\u01aa\u0003\u0002\u0002\u0002\u01a8\u01ab\u0005B"\u0002',
-  '\u01a9\u01ab\u0005\u0006\u0004\u0002\u01aa\u01a8\u0003\u0002\u0002\u0002',
-  '\u01aa\u01a9\u0003\u0002\u0002\u0002\u01ab\u01ad\u0003\u0002\u0002\u0002',
-  '\u01ac\u01ae\u0007\u0099\u0002\u0002\u01ad\u01ac\u0003\u0002\u0002\u0002',
-  '\u01ad\u01ae\u0003\u0002\u0002\u0002\u01ae\u0005\u0003\u0002\u0002\u0002',
-  '\u01af\u01b2\u0005\b\u0005\u0002\u01b0\u01b1\u0007\u0099\u0002\u0002',
-  '\u01b1\u01b3\u0005\n\u0006\u0002\u01b2\u01b0\u0003\u0002\u0002\u0002',
-  '\u01b2\u01b3\u0003\u0002\u0002\u0002\u01b3\u0007\u0003\u0002\u0002\u0002',
-  '\u01b4\u01b5\u0007\u0004\u0002\u0002\u01b5\u01ba\u0005\u0194\u00cb\u0002',
-  '\u01b6\u01b7\u0007\u0005\u0002\u0002\u01b7\u01b9\u0005\u0194\u00cb\u0002',
-  '\u01b8\u01b6\u0003\u0002\u0002\u0002\u01b9\u01bc\u0003\u0002\u0002\u0002',
-  '\u01ba\u01b8\u0003\u0002\u0002\u0002\u01ba\u01bb\u0003\u0002\u0002\u0002',
-  '\u01bb\t\u0003\u0002\u0002\u0002\u01bc\u01ba\u0003\u0002\u0002\u0002',
-  '\u01bd\u01c2\u0005\f\u0007\u0002\u01be\u01bf\u0007\u0099\u0002\u0002',
-  '\u01bf\u01c1\u0005\f\u0007\u0002\u01c0\u01be\u0003\u0002\u0002\u0002',
-  '\u01c1\u01c4\u0003\u0002\u0002\u0002\u01c2\u01c0\u0003\u0002\u0002\u0002',
-  '\u01c2\u01c3\u0003\u0002\u0002\u0002\u01c3\u000b\u0003\u0002\u0002\u0002',
-  '\u01c4\u01c2\u0003\u0002\u0002\u0002\u01c5\u01d0\u0005\u0010\t\u0002',
-  '\u01c6\u01d0\u00052\u001a\u0002\u01c7\u01d0\u0005\u000e\b\u0002\u01c8',
-  '\u01d0\u0005\u016a\u00b6\u0002\u01c9\u01d0\u0005<\u001f\u0002\u01ca',
-  '\u01d0\u0005\u0144\u00a3\u0002\u01cb\u01d0\u0005\u0168\u00b5\u0002\u01cc',
-  '\u01d0\u0005\u0146\u00a4\u0002\u01cd\u01d0\u0005@!\u0002\u01ce\u01d0',
-  '\u0005> \u0002\u01cf\u01c5\u0003\u0002\u0002\u0002\u01cf\u01c6\u0003',
-  '\u0002\u0002\u0002\u01cf\u01c7\u0003\u0002\u0002\u0002\u01cf\u01c8\u0003',
-  '\u0002\u0002\u0002\u01cf\u01c9\u0003\u0002\u0002\u0002\u01cf\u01ca\u0003',
-  '\u0002\u0002\u0002\u01cf\u01cb\u0003\u0002\u0002\u0002\u01cf\u01cc\u0003',
-  '\u0002\u0002\u0002\u01cf\u01cd\u0003\u0002\u0002\u0002\u01cf\u01ce\u0003',
-  '\u0002\u0002\u0002\u01d0\r\u0003\u0002\u0002\u0002\u01d1\u01d3\u0005',
-  '\u0194\u00cb\u0002\u01d2\u01d4\u0007\u0099\u0002\u0002\u01d3\u01d2\u0003',
-  '\u0002\u0002\u0002\u01d3\u01d4\u0003\u0002\u0002\u0002\u01d4\u01d5\u0003',
-  '\u0002\u0002\u0002\u01d5\u01d7\u0007\u0006\u0002\u0002\u01d6\u01d8\u0007',
-  '\u0099\u0002\u0002\u01d7\u01d6\u0003\u0002\u0002\u0002\u01d7\u01d8\u0003',
-  '\u0002\u0002\u0002\u01d8\u01d9\u0003\u0002\u0002\u0002\u01d9\u01da\u0005',
-  '\u0102\u0082\u0002\u01da\u000f\u0003\u0002\u0002\u0002\u01db\u01dc\u0005',
-  '\u0012\n\u0002\u01dc\u0011\u0003\u0002\u0002\u0002\u01dd\u01de\u0005',
-  '\u0014\u000b\u0002\u01de\u01e0\u0007\u0007\u0002\u0002\u01df\u01e1\u0005',
-  '"\u0012\u0002\u01e0\u01df\u0003\u0002\u0002\u0002\u01e0\u01e1\u0003',
-  '\u0002\u0002\u0002\u01e1\u01e2\u0003\u0002\u0002\u0002\u01e2\u01e5\u0005',
-  '\u0016\f\u0002\u01e3\u01e4\u0007\u0004\u0002\u0002\u01e4\u01e6\u0005',
-  '\u001c\u000f\u0002\u01e5\u01e3\u0003\u0002\u0002\u0002\u01e5\u01e6\u0003',
-  '\u0002\u0002\u0002\u01e6\u01e9\u0003\u0002\u0002\u0002\u01e7\u01e8\u0007',
-  '\b\u0002\u0002\u01e8\u01ea\u0005\u001e\u0010\u0002\u01e9\u01e7\u0003',
-  '\u0002\u0002\u0002\u01e9\u01ea\u0003\u0002\u0002\u0002\u01ea\u01ec\u0003',
-  '\u0002\u0002\u0002\u01eb\u01ed\u0005(\u0015\u0002\u01ec\u01eb\u0003',
-  '\u0002\u0002\u0002\u01ec\u01ed\u0003\u0002\u0002\u0002\u01ed\u01ef\u0003',
-  '\u0002\u0002\u0002\u01ee\u01f0\u0005&\u0014\u0002\u01ef\u01ee\u0003',
-  '\u0002\u0002\u0002\u01ef\u01f0\u0003\u0002\u0002\u0002\u01f0\u0013\u0003',
-  '\u0002\u0002\u0002\u01f1\u01f2\u0005.\u0018\u0002\u01f2\u0015\u0003',
-  '\u0002\u0002\u0002\u01f3\u01f5\u0007\b\u0002\u0002\u01f4\u01f3\u0003',
-  '\u0002\u0002\u0002\u01f4\u01f5\u0003\u0002\u0002\u0002\u01f5\u01f8\u0003',
-  '\u0002\u0002\u0002\u01f6\u01f9\u0005\u0018\r\u0002\u01f7\u01f9\u0005',
-  '\u001a\u000e\u0002\u01f8\u01f6\u0003\u0002\u0002\u0002\u01f8\u01f7\u0003',
-  '\u0002\u0002\u0002\u01f9\u0017\u0003\u0002\u0002\u0002\u01fa\u01ff\u0005',
-  '.\u0018\u0002\u01fb\u01fc\u0007\t\u0002\u0002\u01fc\u01fe\u0005.\u0018',
-  '\u0002\u01fd\u01fb\u0003\u0002\u0002\u0002\u01fe\u0201\u0003\u0002\u0002',
-  '\u0002\u01ff\u01fd\u0003\u0002\u0002\u0002\u01ff\u0200\u0003\u0002\u0002',
-  '\u0002\u0200\u0019\u0003\u0002\u0002\u0002\u0201\u01ff\u0003\u0002\u0002',
-  '\u0002\u0202\u0203\u00050\u0019\u0002\u0203\u0204\u0007\t\u0002\u0002',
-  '\u0204\u0205\u00050\u0019\u0002\u0205\u0206\u0007\t\u0002\u0002\u0206',
-  '\u0207\u00050\u0019\u0002\u0207\u0208\u0007\t\u0002\u0002\u0208\u0209',
-  '\u00050\u0019\u0002\u0209\u001b\u0003\u0002\u0002\u0002\u020a\u020b',
-  '\u00050\u0019\u0002\u020b\u001d\u0003\u0002\u0002\u0002\u020c\u0211',
-  '\u0005.\u0018\u0002\u020d\u020e\u0007\b\u0002\u0002\u020e\u0210\u0005',
-  '.\u0018\u0002\u020f\u020d\u0003\u0002\u0002\u0002\u0210\u0213\u0003',
-  '\u0002\u0002\u0002\u0211\u020f\u0003\u0002\u0002\u0002\u0211\u0212\u0003',
-  '\u0002\u0002\u0002\u0212\u001f\u0003\u0002\u0002\u0002\u0213\u0211\u0003',
-  '\u0002\u0002\u0002\u0214\u0215\u0005.\u0018\u0002\u0215!\u0003\u0002',
-  '\u0002\u0002\u0216\u0217\u0005 \u0011\u0002\u0217\u0218\u0007\u0004',
-  '\u0002\u0002\u0218\u0219\u0005$\u0013\u0002\u0219\u021a\u0007\n\u0002',
-  '\u0002\u021a#\u0003\u0002\u0002\u0002\u021b\u021c\u0005.\u0018\u0002',
-  '\u021c%\u0003\u0002\u0002\u0002\u021d\u021e\u0007\u000b\u0002\u0002',
-  "\u021e\u021f\u0005.\u0018\u0002\u021f'\u0003\u0002\u0002\u0002\u0220",
-  '\u0221\u0007\f\u0002\u0002\u0221\u0222\u0005*\u0016\u0002\u0222)\u0003',
-  '\u0002\u0002\u0002\u0223\u0228\u0005,\u0017\u0002\u0224\u0225\u0007',
-  '\r\u0002\u0002\u0225\u0227\u0005,\u0017\u0002\u0226\u0224\u0003\u0002',
-  '\u0002\u0002\u0227\u022a\u0003\u0002\u0002\u0002\u0228\u0226\u0003\u0002',
-  '\u0002\u0002\u0228\u0229\u0003\u0002\u0002\u0002\u0229+\u0003\u0002',
-  '\u0002\u0002\u022a\u0228\u0003\u0002\u0002\u0002\u022b\u0232\u0005.',
-  '\u0018\u0002\u022c\u0230\u0007\u000e\u0002\u0002\u022d\u0231\u0005.',
-  '\u0018\u0002\u022e\u0231\u00050\u0019\u0002\u022f\u0231\u0007\u0087',
-  '\u0002\u0002\u0230\u022d\u0003\u0002\u0002\u0002\u0230\u022e\u0003\u0002',
-  '\u0002\u0002\u0230\u022f\u0003\u0002\u0002\u0002\u0231\u0233\u0003\u0002',
-  '\u0002\u0002\u0232\u022c\u0003\u0002\u0002\u0002\u0232\u0233\u0003\u0002',
-  '\u0002\u0002\u0233-\u0003\u0002\u0002\u0002\u0234\u023b\u0005\u0194',
-  '\u00cb\u0002\u0235\u0237\t\u0002\u0002\u0002\u0236\u0235\u0003\u0002',
-  '\u0002\u0002\u0236\u0237\u0003\u0002\u0002\u0002\u0237\u0238\u0003\u0002',
-  '\u0002\u0002\u0238\u023a\u0005\u0194\u00cb\u0002\u0239\u0236\u0003\u0002',
-  '\u0002\u0002\u023a\u023d\u0003\u0002\u0002\u0002\u023b\u023c\u0003\u0002',
-  '\u0002\u0002\u023b\u0239\u0003\u0002\u0002\u0002\u023c/\u0003\u0002',
-  '\u0002\u0002\u023d\u023b\u0003\u0002\u0002\u0002\u023e\u0240\u0005\u0188',
-  '\u00c5\u0002\u023f\u023e\u0003\u0002\u0002\u0002\u0240\u0241\u0003\u0002',
-  '\u0002\u0002\u0241\u023f\u0003\u0002\u0002\u0002\u0241\u0242\u0003\u0002',
-  '\u0002\u0002\u02421\u0003\u0002\u0002\u0002\u0243\u0244\u0005:\u001e',
-  '\u0002\u02443\u0003\u0002\u0002\u0002\u0245\u0247\u0007\u0010\u0002',
-  '\u0002\u0246\u0248\u0007\u0099\u0002\u0002\u0247\u0246\u0003\u0002\u0002',
-  '\u0002\u0247\u0248\u0003\u0002\u0002\u0002\u0248\u0249\u0003\u0002\u0002',
-  '\u0002\u0249\u024b\u00056\u001c\u0002\u024a\u024c\u0007\u0099\u0002',
-  '\u0002\u024b\u024a\u0003\u0002\u0002\u0002\u024b\u024c\u0003\u0002\u0002',
-  '\u0002\u024c\u0257\u0003\u0002\u0002\u0002\u024d\u024f\u0007\u0011\u0002',
-  '\u0002\u024e\u0250\u0007\u0099\u0002\u0002\u024f\u024e\u0003\u0002\u0002',
-  '\u0002\u024f\u0250\u0003\u0002\u0002\u0002\u0250\u0251\u0003\u0002\u0002',
-  '\u0002\u0251\u0253\u00056\u001c\u0002\u0252\u0254\u0007\u0099\u0002',
-  '\u0002\u0253\u0252\u0003\u0002\u0002\u0002\u0253\u0254\u0003\u0002\u0002',
-  '\u0002\u0254\u0256\u0003\u0002\u0002\u0002\u0255\u024d\u0003\u0002\u0002',
-  '\u0002\u0256\u0259\u0003\u0002\u0002\u0002\u0257\u0255\u0003\u0002\u0002',
-  '\u0002\u0257\u0258\u0003\u0002\u0002\u0002\u0258\u025a\u0003\u0002\u0002',
-  '\u0002\u0259\u0257\u0003\u0002\u0002\u0002\u025a\u025b\u0007\u0012\u0002',
-  '\u0002\u025b\u0262\u0003\u0002\u0002\u0002\u025c\u025e\u0007\u0010\u0002',
-  '\u0002\u025d\u025f\u0007\u0099\u0002\u0002\u025e\u025d\u0003\u0002\u0002',
-  '\u0002\u025e\u025f\u0003\u0002\u0002\u0002\u025f\u0260\u0003\u0002\u0002',
-  '\u0002\u0260\u0262\u0007\u0012\u0002\u0002\u0261\u0245\u0003\u0002\u0002',
-  '\u0002\u0261\u025c\u0003\u0002\u0002\u0002\u02625\u0003\u0002\u0002',
-  '\u0002\u0263\u0265\u0005\u0144\u00a3\u0002\u0264\u0266\u0007\u0099\u0002',
-  '\u0002\u0265\u0264\u0003\u0002\u0002\u0002\u0265\u0266\u0003\u0002\u0002',
-  '\u0002\u0266\u0267\u0003\u0002\u0002\u0002\u0267\u0269\u0007\u0004\u0002',
-  '\u0002\u0268\u026a\u0007\u0099\u0002\u0002\u0269\u0268\u0003\u0002\u0002',
-  '\u0002\u0269\u026a\u0003\u0002\u0002\u0002\u026a\u026b\u0003\u0002\u0002',
-  '\u0002\u026b\u026c\u0005:\u001e\u0002\u026c7\u0003\u0002\u0002\u0002',
-  '\u026d\u026f\u0007\u0013\u0002\u0002\u026e\u0270\u0007\u0099\u0002\u0002',
-  '\u026f\u026e\u0003\u0002\u0002\u0002\u026f\u0270\u0003\u0002\u0002\u0002',
-  '\u0270\u0271\u0003\u0002\u0002\u0002\u0271\u0273\u0005:\u001e\u0002',
-  '\u0272\u0274\u0007\u0099\u0002\u0002\u0273\u0272\u0003\u0002\u0002\u0002',
-  '\u0273\u0274\u0003\u0002\u0002\u0002\u0274\u027f\u0003\u0002\u0002\u0002',
-  '\u0275\u0277\u0007\u0011\u0002\u0002\u0276\u0278\u0007\u0099\u0002\u0002',
-  '\u0277\u0276\u0003\u0002\u0002\u0002\u0277\u0278\u0003\u0002\u0002\u0002',
-  '\u0278\u0279\u0003\u0002\u0002\u0002\u0279\u027b\u0005:\u001e\u0002',
-  '\u027a\u027c\u0007\u0099\u0002\u0002\u027b\u027a\u0003\u0002\u0002\u0002',
-  '\u027b\u027c\u0003\u0002\u0002\u0002\u027c\u027e\u0003\u0002\u0002\u0002',
-  '\u027d\u0275\u0003\u0002\u0002\u0002\u027e\u0281\u0003\u0002\u0002\u0002',
-  '\u027f\u027d\u0003\u0002\u0002\u0002\u027f\u0280\u0003\u0002\u0002\u0002',
-  '\u0280\u0282\u0003\u0002\u0002\u0002\u0281\u027f\u0003\u0002\u0002\u0002',
-  '\u0282\u0283\u0007\u0014\u0002\u0002\u0283\u028a\u0003\u0002\u0002\u0002',
-  '\u0284\u0286\u0007\u0013\u0002\u0002\u0285\u0287\u0007\u0099\u0002\u0002',
-  '\u0286\u0285\u0003\u0002\u0002\u0002\u0286\u0287\u0003\u0002\u0002\u0002',
-  '\u0287\u0288\u0003\u0002\u0002\u0002\u0288\u028a\u0007\u0014\u0002\u0002',
-  '\u0289\u026d\u0003\u0002\u0002\u0002\u0289\u0284\u0003\u0002\u0002\u0002',
-  '\u028a9\u0003\u0002\u0002\u0002\u028b\u0292\u0005\u0144\u00a3\u0002',
-  '\u028c\u0292\u0005\u0168\u00b5\u0002\u028d\u0292\u00054\u001b\u0002',
-  '\u028e\u0292\u00058\u001d\u0002\u028f\u0292\u0005\u0146\u00a4\u0002',
-  '\u0290\u0292\u0007t\u0002\u0002\u0291\u028b\u0003\u0002\u0002\u0002',
-  '\u0291\u028c\u0003\u0002\u0002\u0002\u0291\u028d\u0003\u0002\u0002\u0002',
-  '\u0291\u028e\u0003\u0002\u0002\u0002\u0291\u028f\u0003\u0002\u0002\u0002',
-  '\u0291\u0290\u0003\u0002\u0002\u0002\u0292;\u0003\u0002\u0002\u0002',
-  '\u0293\u0294\u0005\u0166\u00b4\u0002\u0294\u0295\u0007\u0004\u0002\u0002',
-  '\u0295\u029a\u0007\u0099\u0002\u0002\u0296\u029b\u0007\u0086\u0002\u0002',
-  '\u0297\u029b\u0005\u0168\u00b5\u0002\u0298\u029b\u0005\u0146\u00a4\u0002',
-  '\u0299\u029b\u0005\u0194\u00cb\u0002\u029a\u0296\u0003\u0002\u0002\u0002',
-  '\u029a\u0297\u0003\u0002\u0002\u0002\u029a\u0298\u0003\u0002\u0002\u0002',
-  '\u029a\u0299\u0003\u0002\u0002\u0002\u029b=\u0003\u0002\u0002\u0002',
-  '\u029c\u029f\u0007\b\u0002\u0002\u029d\u02a0\u0005\u0194\u00cb\u0002',
-  '\u029e\u02a0\u0005\u0168\u00b5\u0002\u029f\u029d\u0003\u0002\u0002\u0002',
-  '\u029f\u029e\u0003\u0002\u0002\u0002\u02a0\u02a2\u0003\u0002\u0002\u0002',
-  '\u02a1\u029c\u0003\u0002\u0002\u0002\u02a2\u02a3\u0003\u0002\u0002\u0002',
-  '\u02a3\u02a1\u0003\u0002\u0002\u0002\u02a3\u02a4\u0003\u0002\u0002\u0002',
-  '\u02a4\u02a6\u0003\u0002\u0002\u0002\u02a5\u02a7\u0007\b\u0002\u0002',
-  '\u02a6\u02a5\u0003\u0002\u0002\u0002\u02a6\u02a7\u0003\u0002\u0002\u0002',
-  '\u02a7?\u0003\u0002\u0002\u0002\u02a8\u02ad\u0005\u0194\u00cb\u0002',
-  '\u02a9\u02aa\u0007\u0005\u0002\u0002\u02aa\u02ac\u0005\u0194\u00cb\u0002',
-  '\u02ab\u02a9\u0003\u0002\u0002\u0002\u02ac\u02af\u0003\u0002\u0002\u0002',
-  '\u02ad\u02ab\u0003\u0002\u0002\u0002\u02ad\u02ae\u0003\u0002\u0002\u0002',
-  '\u02aeA\u0003\u0002\u0002\u0002\u02af\u02ad\u0003\u0002\u0002\u0002',
-  '\u02b0\u02b1\u0005D#\u0002\u02b1\u02b2\u0005R*\u0002\u02b2C\u0003\u0002',
-  '\u0002\u0002\u02b3\u02b5\u0005F$\u0002\u02b4\u02b6\u0007\u0099\u0002',
-  '\u0002\u02b5\u02b4\u0003\u0002\u0002\u0002\u02b5\u02b6\u0003\u0002\u0002',
-  '\u0002\u02b6\u02b8\u0003\u0002\u0002\u0002\u02b7\u02b3\u0003\u0002\u0002',
-  '\u0002\u02b8\u02bb\u0003\u0002\u0002\u0002\u02b9\u02b7\u0003\u0002\u0002',
-  '\u0002\u02b9\u02ba\u0003\u0002\u0002\u0002\u02baE\u0003\u0002\u0002',
-  '\u0002\u02bb\u02b9\u0003\u0002\u0002\u0002\u02bc\u02c0\u0005H%\u0002',
-  "\u02bd\u02c0\u0005L'\u0002\u02be\u02c0\u0005N(\u0002\u02bf\u02bc\u0003",
-  '\u0002\u0002\u0002\u02bf\u02bd\u0003\u0002\u0002\u0002\u02bf\u02be\u0003',
-  '\u0002\u0002\u0002\u02c0G\u0003\u0002\u0002\u0002\u02c1\u02c4\u0007',
-  '8\u0002\u0002\u02c2\u02c3\u0007\u0099\u0002\u0002\u02c3\u02c5\u0005',
-  'J&\u0002\u02c4\u02c2\u0003\u0002\u0002\u0002\u02c4\u02c5\u0003\u0002',
-  '\u0002\u0002\u02c5\u02ca\u0003\u0002\u0002\u0002\u02c6\u02c7\u0007\u0099',
-  '\u0002\u0002\u02c7\u02c9\u0005P)\u0002\u02c8\u02c6\u0003\u0002\u0002',
-  '\u0002\u02c9\u02cc\u0003\u0002\u0002\u0002\u02ca\u02c8\u0003\u0002\u0002',
-  '\u0002\u02ca\u02cb\u0003\u0002\u0002\u0002\u02cbI\u0003\u0002\u0002',
-  '\u0002\u02cc\u02ca\u0003\u0002\u0002\u0002\u02cd\u02ce\u0007\u0094\u0002',
-  '\u0002\u02ceK\u0003\u0002\u0002\u0002\u02cf\u02d0\u00079\u0002\u0002',
-  '\u02d0M\u0003\u0002\u0002\u0002\u02d1\u02d2\u0007:\u0002\u0002\u02d2',
-  'O\u0003\u0002\u0002\u0002\u02d3\u02d5\u0005\u0194\u00cb\u0002\u02d4',
-  '\u02d6\u0007\u0099\u0002\u0002\u02d5\u02d4\u0003\u0002\u0002\u0002\u02d5',
-  '\u02d6\u0003\u0002\u0002\u0002\u02d6\u02d7\u0003\u0002\u0002\u0002\u02d7',
-  '\u02d9\u0007\u000e\u0002\u0002\u02d8\u02da\u0007\u0099\u0002\u0002\u02d9',
-  '\u02d8\u0003\u0002\u0002\u0002\u02d9\u02da\u0003\u0002\u0002\u0002\u02da',
-  '\u02db\u0003\u0002\u0002\u0002\u02db\u02dc\u0005\u0194\u00cb\u0002\u02dc',
-  'Q\u0003\u0002\u0002\u0002\u02dd\u02e0\u0005d3\u0002\u02de\u02e0\u0005',
-  'T+\u0002\u02df\u02dd\u0003\u0002\u0002\u0002\u02df\u02de\u0003\u0002',
-  '\u0002\u0002\u02e0S\u0003\u0002\u0002\u0002\u02e1\u02e4\u0005V,\u0002',
-  '\u02e2\u02e4\u0005X-\u0002\u02e3\u02e1\u0003\u0002\u0002\u0002\u02e3',
-  '\u02e2\u0003\u0002\u0002\u0002\u02e4U\u0003\u0002\u0002\u0002\u02e5',
-  '\u02ec\u0005Z.\u0002\u02e6\u02e8\u0007\u0099\u0002\u0002\u02e7\u02e6',
-  '\u0003\u0002\u0002\u0002\u02e7\u02e8\u0003\u0002\u0002\u0002\u02e8\u02e9',
-  '\u0003\u0002\u0002\u0002\u02e9\u02eb\u0005`1\u0002\u02ea\u02e7\u0003',
-  '\u0002\u0002\u0002\u02eb\u02ee\u0003\u0002\u0002\u0002\u02ec\u02ea\u0003',
-  '\u0002\u0002\u0002\u02ec\u02ed\u0003\u0002\u0002\u0002\u02edW\u0003',
-  '\u0002\u0002\u0002\u02ee\u02ec\u0003\u0002\u0002\u0002\u02ef\u02f1\u0005',
-  '\\/\u0002\u02f0\u02f2\u0007\u0099\u0002\u0002\u02f1\u02f0\u0003\u0002',
-  '\u0002\u0002\u02f1\u02f2\u0003\u0002\u0002\u0002\u02f2\u02f3\u0003\u0002',
-  '\u0002\u0002\u02f3\u02f4\u0005^0\u0002\u02f4Y\u0003\u0002\u0002\u0002',
-  '\u02f5\u02fc\u0005b2\u0002\u02f6\u02f8\u0007\u0099\u0002\u0002\u02f7',
-  '\u02f6\u0003\u0002\u0002\u0002\u02f7\u02f8\u0003\u0002\u0002\u0002\u02f8',
-  '\u02f9\u0003\u0002\u0002\u0002\u02f9\u02fb\u0005b2\u0002\u02fa\u02f7',
-  '\u0003\u0002\u0002\u0002\u02fb\u02fe\u0003\u0002\u0002\u0002\u02fc\u02fa',
-  '\u0003\u0002\u0002\u0002\u02fc\u02fd\u0003\u0002\u0002\u0002\u02fd[',
-  '\u0003\u0002\u0002\u0002\u02fe\u02fc\u0003\u0002\u0002\u0002\u02ff\u0300',
-  '\u0007;\u0002\u0002\u0300\u0301\u0007\u0099\u0002\u0002\u0301\u0302',
-  '\u0007<\u0002\u0002\u0302\u0303\u0007\u0099\u0002\u0002\u0303\u0306',
-  '\u0007=\u0002\u0002\u0304\u0305\u0007\u0099\u0002\u0002\u0305\u0307',
-  '\u0005\u0188\u00c5\u0002\u0306\u0304\u0003\u0002\u0002\u0002\u0306\u0307',
-  '\u0003\u0002\u0002\u0002\u0307]\u0003\u0002\u0002\u0002\u0308\u030f',
-  '\u0005\u0086D\u0002\u0309\u030b\u0007\u0099\u0002\u0002\u030a\u0309',
-  '\u0003\u0002\u0002\u0002\u030a\u030b\u0003\u0002\u0002\u0002\u030b\u030c',
-  '\u0003\u0002\u0002\u0002\u030c\u030e\u0005b2\u0002\u030d\u030a\u0003',
-  '\u0002\u0002\u0002\u030e\u0311\u0003\u0002\u0002\u0002\u030f\u030d\u0003',
-  '\u0002\u0002\u0002\u030f\u0310\u0003\u0002\u0002\u0002\u0310_\u0003',
-  '\u0002\u0002\u0002\u0311\u030f\u0003\u0002\u0002\u0002\u0312\u0313\u0007',
-  '>\u0002\u0002\u0313\u0314\u0007\u0099\u0002\u0002\u0314\u0316\u0007',
-  '?\u0002\u0002\u0315\u0317\u0007\u0099\u0002\u0002\u0316\u0315\u0003',
-  '\u0002\u0002\u0002\u0316\u0317\u0003\u0002\u0002\u0002\u0317\u0318\u0003',
-  '\u0002\u0002\u0002\u0318\u031f\u0005Z.\u0002\u0319\u031b\u0007>\u0002',
-  '\u0002\u031a\u031c\u0007\u0099\u0002\u0002\u031b\u031a\u0003\u0002\u0002',
-  '\u0002\u031b\u031c\u0003\u0002\u0002\u0002\u031c\u031d\u0003\u0002\u0002',
-  '\u0002\u031d\u031f\u0005Z.\u0002\u031e\u0312\u0003\u0002\u0002\u0002',
-  '\u031e\u0319\u0003\u0002\u0002\u0002\u031fa\u0003\u0002\u0002\u0002',
-  '\u0320\u032f\u0005\u0086D\u0002\u0321\u032f\u0005\u00c6d\u0002\u0322',
-  '\u032f\u0005\u0088E\u0002\u0323\u032f\u0005\u008aF\u0002\u0324\u032f',
-  '\u0005\u008cG\u0002\u0325\u032f\u0005\u0090I\u0002\u0326\u032f\u0005',
-  '\u0092J\u0002\u0327\u032f\u0005\u0094K\u0002\u0328\u032f\u0005\u0098',
-  'M\u0002\u0329\u032f\u0005\u009aN\u0002\u032a\u032f\u0005\u009eP\u0002',
-  '\u032b\u032f\u0005\u00a0Q\u0002\u032c\u032f\u0005\u00a2R\u0002\u032d',
-  '\u032f\u0005\u00aaV\u0002\u032e\u0320\u0003\u0002\u0002\u0002\u032e',
-  '\u0321\u0003\u0002\u0002\u0002\u032e\u0322\u0003\u0002\u0002\u0002\u032e',
-  '\u0323\u0003\u0002\u0002\u0002\u032e\u0324\u0003\u0002\u0002\u0002\u032e',
-  '\u0325\u0003\u0002\u0002\u0002\u032e\u0326\u0003\u0002\u0002\u0002\u032e',
-  '\u0327\u0003\u0002\u0002\u0002\u032e\u0328\u0003\u0002\u0002\u0002\u032e',
-  '\u0329\u0003\u0002\u0002\u0002\u032e\u032a\u0003\u0002\u0002\u0002\u032e',
-  '\u032b\u0003\u0002\u0002\u0002\u032e\u032c\u0003\u0002\u0002\u0002\u032e',
-  '\u032d\u0003\u0002\u0002\u0002\u032fc\u0003\u0002\u0002\u0002\u0330',
-  '\u033b\u0005n8\u0002\u0331\u033b\u0005x=\u0002\u0332\u033b\u0005f4\u0002',
-  '\u0333\u033b\u0005p9\u0002\u0334\u033b\u0005h5\u0002\u0335\u033b\u0005',
-  'r:\u0002\u0336\u033b\u0005j6\u0002\u0337\u033b\u0005t;\u0002\u0338\u033b',
-  '\u0005l7\u0002\u0339\u033b\u0005v<\u0002\u033a\u0330\u0003\u0002\u0002',
-  '\u0002\u033a\u0331\u0003\u0002\u0002\u0002\u033a\u0332\u0003\u0002\u0002',
-  '\u0002\u033a\u0333\u0003\u0002\u0002\u0002\u033a\u0334\u0003\u0002\u0002',
-  '\u0002\u033a\u0335\u0003\u0002\u0002\u0002\u033a\u0336\u0003\u0002\u0002',
-  '\u0002\u033a\u0337\u0003\u0002\u0002\u0002\u033a\u0338\u0003\u0002\u0002',
-  '\u0002\u033a\u0339\u0003\u0002\u0002\u0002\u033be\u0003\u0002\u0002',
-  '\u0002\u033c\u033d\u0007@\u0002\u0002\u033d\u033e\u0007\u0099\u0002',
-  '\u0002\u033e\u033f\u0005|?\u0002\u033fg\u0003\u0002\u0002\u0002\u0340',
-  '\u0341\u0007@\u0002\u0002\u0341\u0342\u0007\u0099\u0002\u0002\u0342',
-  '\u0343\u0005~@\u0002\u0343i\u0003\u0002\u0002\u0002\u0344\u0345\u0007',
-  '@\u0002\u0002\u0345\u0346\u0007\u0099\u0002\u0002\u0346\u0347\u0005',
-  '\u0080A\u0002\u0347k\u0003\u0002\u0002\u0002\u0348\u0349\u0007@\u0002',
-  '\u0002\u0349\u034a\u0007\u0099\u0002\u0002\u034a\u034b\u0005\u0082B',
-  '\u0002\u034bm\u0003\u0002\u0002\u0002\u034c\u034d\u0007@\u0002\u0002',
-  '\u034d\u034e\u0007\u0099\u0002\u0002\u034e\u034f\u0005z>\u0002\u034f',
-  'o\u0003\u0002\u0002\u0002\u0350\u0351\u0007A\u0002\u0002\u0351\u0352',
-  '\u0007\u0099\u0002\u0002\u0352\u0353\u0005|?\u0002\u0353q\u0003\u0002',
-  '\u0002\u0002\u0354\u0355\u0007A\u0002\u0002\u0355\u0356\u0007\u0099',
-  '\u0002\u0002\u0356\u0357\u0005~@\u0002\u0357s\u0003\u0002\u0002\u0002',
-  '\u0358\u0359\u0007A\u0002\u0002\u0359\u035a\u0007\u0099\u0002\u0002',
-  '\u035a\u035b\u0005\u0080A\u0002\u035bu\u0003\u0002\u0002\u0002\u035c',
-  '\u035d\u0007A\u0002\u0002\u035d\u035e\u0007\u0099\u0002\u0002\u035e',
-  '\u035f\u0005\u0082B\u0002\u035fw\u0003\u0002\u0002\u0002\u0360\u0361',
-  '\u0007A\u0002\u0002\u0361\u0362\u0007\u0099\u0002\u0002\u0362\u0363',
-  '\u0005z>\u0002\u0363y\u0003\u0002\u0002\u0002\u0364\u0365\u0007B\u0002',
-  '\u0002\u0365\u0366\u0007\u0099\u0002\u0002\u0366\u0368\u0007C\u0002',
-  '\u0002\u0367\u0369\u0007\u0099\u0002\u0002\u0368\u0367\u0003\u0002\u0002',
-  '\u0002\u0368\u0369\u0003\u0002\u0002\u0002\u0369\u036a\u0003\u0002\u0002',
-  '\u0002\u036a\u036c\u0005\u00fa~\u0002\u036b\u036d\u0007\u0099\u0002',
-  '\u0002\u036c\u036b\u0003\u0002\u0002\u0002\u036c\u036d\u0003\u0002\u0002',
-  '\u0002\u036d\u036e\u0003\u0002\u0002\u0002\u036e\u0370\u0007\u0015\u0002',
-  '\u0002\u036f\u0371\u0007\u0099\u0002\u0002\u0370\u036f\u0003\u0002\u0002',
-  '\u0002\u0370\u0371\u0003\u0002\u0002\u0002\u0371\u0372\u0003\u0002\u0002',
-  '\u0002\u0372\u0374\u0005\u0184\u00c3\u0002\u0373\u0375\u0007\u0099\u0002',
-  '\u0002\u0374\u0373\u0003\u0002\u0002\u0002\u0374\u0375\u0003\u0002\u0002',
-  '\u0002\u0375\u0376\u0003\u0002\u0002\u0002\u0376\u0377\u0007\u0016\u0002',
-  '\u0002\u0377{\u0003\u0002\u0002\u0002\u0378\u0379\u0007D\u0002\u0002',
-  '\u0379\u037a\u0007\u0099\u0002\u0002\u037a\u037c\u0007C\u0002\u0002',
-  '\u037b\u037d\u0007\u0099\u0002\u0002\u037c\u037b\u0003\u0002\u0002\u0002',
-  '\u037c\u037d\u0003\u0002\u0002\u0002\u037d\u037e\u0003\u0002\u0002\u0002',
-  '\u037e\u0380\u0007\u0015\u0002\u0002\u037f\u0381\u0007\u0099\u0002\u0002',
-  '\u0380\u037f\u0003\u0002\u0002\u0002\u0380\u0381\u0003\u0002\u0002\u0002',
-  '\u0381\u0382\u0003\u0002\u0002\u0002\u0382\u0383\u0005\u0166\u00b4\u0002',
-  '\u0383\u0385\u0005\u00fa~\u0002\u0384\u0386\u0007\u0099\u0002\u0002',
-  '\u0385\u0384\u0003\u0002\u0002\u0002\u0385\u0386\u0003\u0002\u0002\u0002',
-  '\u0386\u0387\u0003\u0002\u0002\u0002\u0387\u0389\u0007\u0016\u0002\u0002',
-  '\u0388\u038a\u0007\u0099\u0002\u0002\u0389\u0388\u0003\u0002\u0002\u0002',
-  '\u0389\u038a\u0003\u0002\u0002\u0002\u038a\u038b\u0003\u0002\u0002\u0002',
-  '\u038b\u038c\u0007E\u0002\u0002\u038c\u038d\u0007\u0099\u0002\u0002',
-  '\u038d\u038e\u0005\u0182\u00c2\u0002\u038e\u038f\u0007\u0099\u0002\u0002',
-  '\u038f\u0390\u0007F\u0002\u0002\u0390\u0391\u0007\u0099\u0002\u0002',
-  '\u0391\u0392\u0007G\u0002\u0002\u0392}\u0003\u0002\u0002\u0002\u0393',
-  '\u0394\u0007D\u0002\u0002\u0394\u0395\u0007\u0099\u0002\u0002\u0395',
-  '\u0397\u0007C\u0002\u0002\u0396\u0398\u0007\u0099\u0002\u0002\u0397',
-  '\u0396\u0003\u0002\u0002\u0002\u0397\u0398\u0003\u0002\u0002\u0002\u0398',
-  '\u0399\u0003\u0002\u0002\u0002\u0399\u039b\u0007\u0015\u0002\u0002\u039a',
-  '\u039c\u0007\u0099\u0002\u0002\u039b\u039a\u0003\u0002\u0002\u0002\u039b',
-  '\u039c\u0003\u0002\u0002\u0002\u039c\u039d\u0003\u0002\u0002\u0002\u039d',
-  '\u039e\u0005\u0166\u00b4\u0002\u039e\u03a0\u0005\u00fa~\u0002\u039f',
-  '\u03a1\u0007\u0099\u0002\u0002\u03a0\u039f\u0003\u0002\u0002\u0002\u03a0',
-  '\u03a1\u0003\u0002\u0002\u0002\u03a1\u03a2\u0003\u0002\u0002\u0002\u03a2',
-  '\u03a4\u0007\u0016\u0002\u0002\u03a3\u03a5\u0007\u0099\u0002\u0002\u03a4',
-  '\u03a3\u0003\u0002\u0002\u0002\u03a4\u03a5\u0003\u0002\u0002\u0002\u03a5',
-  '\u03a6\u0003\u0002\u0002\u0002\u03a6\u03a7\u0007E\u0002\u0002\u03a7',
-  '\u03a8\u0007\u0099\u0002\u0002\u03a8\u03aa\u0007\u0015\u0002\u0002\u03a9',
-  '\u03ab\u0007\u0099\u0002\u0002\u03aa\u03a9\u0003\u0002\u0002\u0002\u03aa',
-  '\u03ab\u0003\u0002\u0002\u0002\u03ab\u03ac\u0003\u0002\u0002\u0002\u03ac',
-  '\u03ae\u0005\u0180\u00c1\u0002\u03ad\u03af\u0007\u0099\u0002\u0002\u03ae',
-  '\u03ad\u0003\u0002\u0002\u0002\u03ae\u03af\u0003\u0002\u0002\u0002\u03af',
-  '\u03b0\u0003\u0002\u0002\u0002\u03b0\u03b1\u0007\u0016\u0002\u0002\u03b1',
-  '\u03b2\u0007\u0099\u0002\u0002\u03b2\u03b3\u0007F\u0002\u0002\u03b3',
-  '\u03b4\u0007\u0099\u0002\u0002\u03b4\u03b5\u0007g\u0002\u0002\u03b5',
-  '\u03b6\u0007\u0099\u0002\u0002\u03b6\u03b7\u0007\u0085\u0002\u0002\u03b7',
-  '\u007f\u0003\u0002\u0002\u0002\u03b8\u03b9\u0007D\u0002\u0002\u03b9',
-  '\u03ba\u0007\u0099\u0002\u0002\u03ba\u03bc\u0007C\u0002\u0002\u03bb',
-  '\u03bd\u0007\u0099\u0002\u0002\u03bc\u03bb\u0003\u0002\u0002\u0002\u03bc',
-  '\u03bd\u0003\u0002\u0002\u0002\u03bd\u03be\u0003\u0002\u0002\u0002\u03be',
-  '\u03bf\u0007\u0015\u0002\u0002\u03bf\u03c0\u0005\u0166\u00b4\u0002\u03c0',
-  '\u03c1\u0005\u00fa~\u0002\u03c1\u03c3\u0007\u0016\u0002\u0002\u03c2',
-  '\u03c4\u0007\u0099\u0002\u0002\u03c3\u03c2\u0003\u0002\u0002\u0002\u03c3',
-  '\u03c4\u0003\u0002\u0002\u0002\u03c4\u03c5\u0003\u0002\u0002\u0002\u03c5',
-  '\u03c6\u0007E\u0002\u0002\u03c6\u03c7\u0007\u0099\u0002\u0002\u03c7',
-  '\u03c9\u0007H\u0002\u0002\u03c8\u03ca\u0007\u0099\u0002\u0002\u03c9',
-  '\u03c8\u0003\u0002\u0002\u0002\u03c9\u03ca\u0003\u0002\u0002\u0002\u03ca',
-  '\u03cb\u0003\u0002\u0002\u0002\u03cb\u03cc\u0007\u0015\u0002\u0002\u03cc',
-  '\u03cd\u0005\u0182\u00c2\u0002\u03cd\u03ce\u0007\u0016\u0002\u0002\u03ce',
-  '\u0081\u0003\u0002\u0002\u0002\u03cf\u03d0\u0007D\u0002\u0002\u03d0',
-  '\u03d1\u0007\u0099\u0002\u0002\u03d1\u03d3\u0007C\u0002\u0002\u03d2',
-  '\u03d4\u0007\u0099\u0002\u0002\u03d3\u03d2\u0003\u0002\u0002\u0002\u03d3',
-  '\u03d4\u0003\u0002\u0002\u0002\u03d4\u03d5\u0003\u0002\u0002\u0002\u03d5',
-  '\u03d7\u0005\u0084C\u0002\u03d6\u03d8\u0007\u0099\u0002\u0002\u03d7',
-  '\u03d6\u0003\u0002\u0002\u0002\u03d7\u03d8\u0003\u0002\u0002\u0002\u03d8',
-  '\u03d9\u0003\u0002\u0002\u0002\u03d9\u03da\u0007E\u0002\u0002\u03da',
-  '\u03db\u0007\u0099\u0002\u0002\u03db\u03dd\u0007H\u0002\u0002\u03dc',
-  '\u03de\u0007\u0099\u0002\u0002\u03dd\u03dc\u0003\u0002\u0002\u0002\u03dd',
-  '\u03de\u0003\u0002\u0002\u0002\u03de\u03df\u0003\u0002\u0002\u0002\u03df',
-  '\u03e0\u0007\u0015\u0002\u0002\u03e0\u03e1\u0005\u0182\u00c2\u0002\u03e1',
-  '\u03e2\u0007\u0016\u0002\u0002\u03e2\u0083\u0003\u0002\u0002\u0002\u03e3',
-  '\u03e5\u0007\u0015\u0002\u0002\u03e4\u03e6\u0007\u0099\u0002\u0002\u03e5',
-  '\u03e4\u0003\u0002\u0002\u0002\u03e5\u03e6\u0003\u0002\u0002\u0002\u03e6',
-  '\u03e7\u0003\u0002\u0002\u0002\u03e7\u03e8\u0007\u0016\u0002\u0002\u03e8',
-  '\u03e9\u0005\u0192\u00ca\u0002\u03e9\u03ea\u0007\u0013\u0002\u0002\u03ea',
-  '\u03eb\u0005\u0166\u00b4\u0002\u03eb\u03ec\u0005\u00f0y\u0002\u03ec',
-  '\u03ed\u0007\u0014\u0002\u0002\u03ed\u03ee\u0005\u0192\u00ca\u0002\u03ee',
-  '\u03f0\u0007\u0015\u0002\u0002\u03ef\u03f1\u0007\u0099\u0002\u0002\u03f0',
-  '\u03ef\u0003\u0002\u0002\u0002\u03f0\u03f1\u0003\u0002\u0002\u0002\u03f1',
-  '\u03f2\u0003\u0002\u0002\u0002\u03f2\u03f3\u0007\u0016\u0002\u0002\u03f3',
-  '\u0419\u0003\u0002\u0002\u0002\u03f4\u03f6\u0007\u0015\u0002\u0002\u03f5',
-  '\u03f7\u0007\u0099\u0002\u0002\u03f6\u03f5\u0003\u0002\u0002\u0002\u03f6',
-  '\u03f7\u0003\u0002\u0002\u0002\u03f7\u03f8\u0003\u0002\u0002\u0002\u03f8',
-  '\u03f9\u0007\u0016\u0002\u0002\u03f9\u03fa\u0005\u0192\u00ca\u0002\u03fa',
-  '\u03fb\u0007\u0013\u0002\u0002\u03fb\u03fc\u0005\u0166\u00b4\u0002\u03fc',
-  '\u03fd\u0005\u00f0y\u0002\u03fd\u03fe\u0007\u0014\u0002\u0002\u03fe',
-  '\u03ff\u0005\u0192\u00ca\u0002\u03ff\u0400\u0005\u0190\u00c9\u0002\u0400',
-  '\u0402\u0007\u0015\u0002\u0002\u0401\u0403\u0007\u0099\u0002\u0002\u0402',
-  '\u0401\u0003\u0002\u0002\u0002\u0402\u0403\u0003\u0002\u0002\u0002\u0403',
-  '\u0404\u0003\u0002\u0002\u0002\u0404\u0405\u0007\u0016\u0002\u0002\u0405',
-  '\u0419\u0003\u0002\u0002\u0002\u0406\u0408\u0007\u0015\u0002\u0002\u0407',
-  '\u0409\u0007\u0099\u0002\u0002\u0408\u0407\u0003\u0002\u0002\u0002\u0408',
-  '\u0409\u0003\u0002\u0002\u0002\u0409\u040a\u0003\u0002\u0002\u0002\u040a',
-  '\u040b\u0007\u0016\u0002\u0002\u040b\u040c\u0005\u018e\u00c8\u0002\u040c',
-  '\u040d\u0005\u0192\u00ca\u0002\u040d\u040e\u0007\u0013\u0002\u0002\u040e',
-  '\u040f\u0005\u0166\u00b4\u0002\u040f\u0410\u0005\u00f0y\u0002\u0410',
-  '\u0411\u0007\u0014\u0002\u0002\u0411\u0412\u0005\u0192\u00ca\u0002\u0412',
-  '\u0414\u0007\u0015\u0002\u0002\u0413\u0415\u0007\u0099\u0002\u0002\u0414',
-  '\u0413\u0003\u0002\u0002\u0002\u0414\u0415\u0003\u0002\u0002\u0002\u0415',
-  '\u0416\u0003\u0002\u0002\u0002\u0416\u0417\u0007\u0016\u0002\u0002\u0417',
-  '\u0419\u0003\u0002\u0002\u0002\u0418\u03e3\u0003\u0002\u0002\u0002\u0418',
-  '\u03f4\u0003\u0002\u0002\u0002\u0418\u0406\u0003\u0002\u0002\u0002\u0419',
-  '\u0085\u0003\u0002\u0002\u0002\u041a\u041b\u0007I\u0002\u0002\u041b',
-  '\u041c\u0007\u0099\u0002\u0002\u041c\u041d\u0007J\u0002\u0002\u041d',
-  '\u0422\u0007\u0099\u0002\u0002\u041e\u041f\u0007K\u0002\u0002\u041f',
-  '\u0420\u0007\u0099\u0002\u0002\u0420\u0421\u0007L\u0002\u0002\u0421',
-  '\u0423\u0007\u0099\u0002\u0002\u0422\u041e\u0003\u0002\u0002\u0002\u0422',
-  '\u0423\u0003\u0002\u0002\u0002\u0423\u0424\u0003\u0002\u0002\u0002\u0424',
-  '\u0425\u0007M\u0002\u0002\u0425\u0426\u0007\u0099\u0002\u0002\u0426',
-  '\u0427\u0005\u0102\u0082\u0002\u0427\u0428\u0007\u0099\u0002\u0002\u0428',
-  '\u0429\u0007N\u0002\u0002\u0429\u042a\u0007\u0099\u0002\u0002\u042a',
-  '\u042b\u0005\u0166\u00b4\u0002\u042b\u042f\u0007\u0099\u0002\u0002\u042c',
-  '\u042d\u0007O\u0002\u0002\u042d\u042e\u0007\u0099\u0002\u0002\u042e',
-  '\u0430\u0007\u0086\u0002\u0002\u042f\u042c\u0003\u0002\u0002\u0002\u042f',
-  '\u0430\u0003\u0002\u0002\u0002\u0430\u0087\u0003\u0002\u0002\u0002\u0431',
-  '\u0432\u0007P\u0002\u0002\u0432\u0434\u0007\u0099\u0002\u0002\u0433',
-  '\u0431\u0003\u0002\u0002\u0002\u0433\u0434\u0003\u0002\u0002\u0002\u0434',
-  '\u0435\u0003\u0002\u0002\u0002\u0435\u0437\u0007Q\u0002\u0002\u0436',
-  '\u0438\u0007\u0099\u0002\u0002\u0437\u0436\u0003\u0002\u0002\u0002\u0437',
-  '\u0438\u0003\u0002\u0002\u0002\u0438\u0439\u0003\u0002\u0002\u0002\u0439',
-  '\u043d\u0005\u00dan\u0002\u043a\u043c\u0005\u00c4c\u0002\u043b\u043a',
-  '\u0003\u0002\u0002\u0002\u043c\u043f\u0003\u0002\u0002\u0002\u043d\u043b',
-  '\u0003\u0002\u0002\u0002\u043d\u043e\u0003\u0002\u0002\u0002\u043e\u0444',
-  '\u0003\u0002\u0002\u0002\u043f\u043d\u0003\u0002\u0002\u0002\u0440\u0442',
-  '\u0007\u0099\u0002\u0002\u0441\u0440\u0003\u0002\u0002\u0002\u0441\u0442',
-  '\u0003\u0002\u0002\u0002\u0442\u0443\u0003\u0002\u0002\u0002\u0443\u0445',
-  '\u0005\u00d8m\u0002\u0444\u0441\u0003\u0002\u0002\u0002\u0444\u0445',
-  '\u0003\u0002\u0002\u0002\u0445\u0089\u0003\u0002\u0002\u0002\u0446\u0448',
-  '\u0007R\u0002\u0002\u0447\u0449\u0007\u0099\u0002\u0002\u0448\u0447',
-  '\u0003\u0002\u0002\u0002\u0448\u0449\u0003\u0002\u0002\u0002\u0449\u044a',
-  '\u0003\u0002\u0002\u0002\u044a\u044b\u0005\u0102\u0082\u0002\u044b\u044c',
-  '\u0007\u0099\u0002\u0002\u044c\u044d\u0007N\u0002\u0002\u044d\u044e',
-  '\u0007\u0099\u0002\u0002\u044e\u044f\u0005\u0166\u00b4\u0002\u044f\u008b',
-  '\u0003\u0002\u0002\u0002\u0450\u0452\u0007S\u0002\u0002\u0451\u0453',
-  '\u0007\u0099\u0002\u0002\u0452\u0451\u0003\u0002\u0002\u0002\u0452\u0453',
-  '\u0003\u0002\u0002\u0002\u0453\u0454\u0003\u0002\u0002\u0002\u0454\u0459',
-  '\u0005\u00dco\u0002\u0455\u0456\u0007\u0099\u0002\u0002\u0456\u0458',
-  '\u0005\u008eH\u0002\u0457\u0455\u0003\u0002\u0002\u0002\u0458\u045b',
-  '\u0003\u0002\u0002\u0002\u0459\u0457\u0003\u0002\u0002\u0002\u0459\u045a',
-  '\u0003\u0002\u0002\u0002\u045a\u008d\u0003\u0002\u0002\u0002\u045b\u0459',
-  '\u0003\u0002\u0002\u0002\u045c\u045d\u0007C\u0002\u0002\u045d\u045e',
-  '\u0007\u0099\u0002\u0002\u045e\u045f\u0007Q\u0002\u0002\u045f\u0460',
-  '\u0007\u0099\u0002\u0002\u0460\u0467\u0005\u0094K\u0002\u0461\u0462',
-  '\u0007C\u0002\u0002\u0462\u0463\u0007\u0099\u0002\u0002\u0463\u0464',
-  '\u0007@\u0002\u0002\u0464\u0465\u0007\u0099\u0002\u0002\u0465\u0467',
-  '\u0005\u0094K\u0002\u0466\u045c\u0003\u0002\u0002\u0002\u0466\u0461',
-  '\u0003\u0002\u0002\u0002\u0467\u008f\u0003\u0002\u0002\u0002\u0468\u046a',
-  '\u0007@\u0002\u0002\u0469\u046b\u0007\u0099\u0002\u0002\u046a\u0469',
-  '\u0003\u0002\u0002\u0002\u046a\u046b\u0003\u0002\u0002\u0002\u046b\u046c',
-  '\u0003\u0002\u0002\u0002\u046c\u046d\u0005\u00dan\u0002\u046d\u0091',
-  '\u0003\u0002\u0002\u0002\u046e\u046f\u0007@\u0002\u0002\u046f\u0470',
-  '\u0007\u0099\u0002\u0002\u0470\u0472\u0007G\u0002\u0002\u0471\u0473',
-  '\u0007\u0099\u0002\u0002\u0472\u0471\u0003\u0002\u0002\u0002\u0472\u0473',
-  '\u0003\u0002\u0002\u0002\u0473\u0474\u0003\u0002\u0002\u0002\u0474\u0475',
-  '\u0005\u00dan\u0002\u0475\u0093\u0003\u0002\u0002\u0002\u0476\u0478',
-  '\u0007T\u0002\u0002\u0477\u0479\u0007\u0099\u0002\u0002\u0478\u0477',
-  '\u0003\u0002\u0002\u0002\u0478\u0479\u0003\u0002\u0002\u0002\u0479\u047a',
-  '\u0003\u0002\u0002\u0002\u047a\u0485\u0005\u0096L\u0002\u047b\u047d',
-  '\u0007\u0099\u0002\u0002\u047c\u047b\u0003\u0002\u0002\u0002\u047c\u047d',
-  '\u0003\u0002\u0002\u0002\u047d\u047e\u0003\u0002\u0002\u0002\u047e\u0480',
-  '\u0007\u0011\u0002\u0002\u047f\u0481\u0007\u0099\u0002\u0002\u0480\u047f',
-  '\u0003\u0002\u0002\u0002\u0480\u0481\u0003\u0002\u0002\u0002\u0481\u0482',
-  '\u0003\u0002\u0002\u0002\u0482\u0484\u0005\u0096L\u0002\u0483\u047c',
-  '\u0003\u0002\u0002\u0002\u0484\u0487\u0003\u0002\u0002\u0002\u0485\u0483',
-  '\u0003\u0002\u0002\u0002\u0485\u0486\u0003\u0002\u0002\u0002\u0486\u0095',
-  '\u0003\u0002\u0002\u0002\u0487\u0485\u0003\u0002\u0002\u0002\u0488\u048a',
-  '\u0005\u0182\u00c2\u0002\u0489\u048b\u0007\u0099\u0002\u0002\u048a\u0489',
-  '\u0003\u0002\u0002\u0002\u048a\u048b\u0003\u0002\u0002\u0002\u048b\u048c',
-  '\u0003\u0002\u0002\u0002\u048c\u048e\u0007\u000e\u0002\u0002\u048d\u048f',
-  '\u0007\u0099\u0002\u0002\u048e\u048d\u0003\u0002\u0002\u0002\u048e\u048f',
-  '\u0003\u0002\u0002\u0002\u048f\u0490\u0003\u0002\u0002\u0002\u0490\u0491',
-  '\u0005\u0102\u0082\u0002\u0491\u04ad\u0003\u0002\u0002\u0002\u0492\u0494',
-  '\u0005\u0166\u00b4\u0002\u0493\u0495\u0007\u0099\u0002\u0002\u0494\u0493',
-  '\u0003\u0002\u0002\u0002\u0494\u0495\u0003\u0002\u0002\u0002\u0495\u0496',
-  '\u0003\u0002\u0002\u0002\u0496\u0498\u0007\u000e\u0002\u0002\u0497\u0499',
-  '\u0007\u0099\u0002\u0002\u0498\u0497\u0003\u0002\u0002\u0002\u0498\u0499',
-  '\u0003\u0002\u0002\u0002\u0499\u049a\u0003\u0002\u0002\u0002\u049a\u049b',
-  '\u0005\u0102\u0082\u0002\u049b\u04ad\u0003\u0002\u0002\u0002\u049c\u049e',
-  '\u0005\u0166\u00b4\u0002\u049d\u049f\u0007\u0099\u0002\u0002\u049e\u049d',
-  '\u0003\u0002\u0002\u0002\u049e\u049f\u0003\u0002\u0002\u0002\u049f\u04a0',
-  '\u0003\u0002\u0002\u0002\u04a0\u04a2\u0007\u0017\u0002\u0002\u04a1\u04a3',
-  '\u0007\u0099\u0002\u0002\u04a2\u04a1\u0003\u0002\u0002\u0002\u04a2\u04a3',
-  '\u0003\u0002\u0002\u0002\u04a3\u04a4\u0003\u0002\u0002\u0002\u04a4\u04a5',
-  '\u0005\u0102\u0082\u0002\u04a5\u04ad\u0003\u0002\u0002\u0002\u04a6\u04a8',
-  '\u0005\u0166\u00b4\u0002\u04a7\u04a9\u0007\u0099\u0002\u0002\u04a8\u04a7',
-  '\u0003\u0002\u0002\u0002\u04a8\u04a9\u0003\u0002\u0002\u0002\u04a9\u04aa',
-  '\u0003\u0002\u0002\u0002\u04aa\u04ab\u0005\u00f8}\u0002\u04ab\u04ad',
-  '\u0003\u0002\u0002\u0002\u04ac\u0488\u0003\u0002\u0002\u0002\u04ac\u0492',
-  '\u0003\u0002\u0002\u0002\u04ac\u049c\u0003\u0002\u0002\u0002\u04ac\u04a6',
-  '\u0003\u0002\u0002\u0002\u04ad\u0097\u0003\u0002\u0002\u0002\u04ae\u04af',
-  '\u0007U\u0002\u0002\u04af\u04b1\u0007\u0099\u0002\u0002\u04b0\u04ae',
-  '\u0003\u0002\u0002\u0002\u04b0\u04b1\u0003\u0002\u0002\u0002\u04b1\u04b2',
-  '\u0003\u0002\u0002\u0002\u04b2\u04b4\u0007V\u0002\u0002\u04b3\u04b5',
-  '\u0007\u0099\u0002\u0002\u04b4\u04b3\u0003\u0002\u0002\u0002\u04b4\u04b5',
-  '\u0003\u0002\u0002\u0002\u04b5\u04b6\u0003\u0002\u0002\u0002\u04b6\u04c1',
-  '\u0005\u0102\u0082\u0002\u04b7\u04b9\u0007\u0099\u0002\u0002\u04b8\u04b7',
-  '\u0003\u0002\u0002\u0002\u04b8\u04b9\u0003\u0002\u0002\u0002\u04b9\u04ba',
-  '\u0003\u0002\u0002\u0002\u04ba\u04bc\u0007\u0011\u0002\u0002\u04bb\u04bd',
-  '\u0007\u0099\u0002\u0002\u04bc\u04bb\u0003\u0002\u0002\u0002\u04bc\u04bd',
-  '\u0003\u0002\u0002\u0002\u04bd\u04be\u0003\u0002\u0002\u0002\u04be\u04c0',
-  '\u0005\u0102\u0082\u0002\u04bf\u04b8\u0003\u0002\u0002\u0002\u04c0\u04c3',
-  '\u0003\u0002\u0002\u0002\u04c1\u04bf\u0003\u0002\u0002\u0002\u04c1\u04c2',
-  '\u0003\u0002\u0002\u0002\u04c2\u0099\u0003\u0002\u0002\u0002\u04c3\u04c1',
-  '\u0003\u0002\u0002\u0002\u04c4\u04c5\u0007W\u0002\u0002\u04c5\u04c6',
-  '\u0007\u0099\u0002\u0002\u04c6\u04d1\u0005\u009cO\u0002\u04c7\u04c9',
-  '\u0007\u0099\u0002\u0002\u04c8\u04c7\u0003\u0002\u0002\u0002\u04c8\u04c9',
-  '\u0003\u0002\u0002\u0002\u04c9\u04ca\u0003\u0002\u0002\u0002\u04ca\u04cc',
-  '\u0007\u0011\u0002\u0002\u04cb\u04cd\u0007\u0099\u0002\u0002\u04cc\u04cb',
-  '\u0003\u0002\u0002\u0002\u04cc\u04cd\u0003\u0002\u0002\u0002\u04cd\u04ce',
-  '\u0003\u0002\u0002\u0002\u04ce\u04d0\u0005\u009cO\u0002\u04cf\u04c8',
-  '\u0003\u0002\u0002\u0002\u04d0\u04d3\u0003\u0002\u0002\u0002\u04d1\u04cf',
-  '\u0003\u0002\u0002\u0002\u04d1\u04d2\u0003\u0002\u0002\u0002\u04d2\u009b',
-  '\u0003\u0002\u0002\u0002\u04d3\u04d1\u0003\u0002\u0002\u0002\u04d4\u04d5',
-  '\u0005\u0166\u00b4\u0002\u04d5\u04d6\u0005\u00f8}\u0002\u04d6\u04d9',
-  '\u0003\u0002\u0002\u0002\u04d7\u04d9\u0005\u0182\u00c2\u0002\u04d8\u04d4',
-  '\u0003\u0002\u0002\u0002\u04d8\u04d7\u0003\u0002\u0002\u0002\u04d9\u009d',
-  '\u0003\u0002\u0002\u0002\u04da\u04dc\u0007X\u0002\u0002\u04db\u04dd',
-  '\u0007\u0099\u0002\u0002\u04dc\u04db\u0003\u0002\u0002\u0002\u04dc\u04dd',
-  '\u0003\u0002\u0002\u0002\u04dd\u04de\u0003\u0002\u0002\u0002\u04de\u04e0',
-  '\u0007\u0015\u0002\u0002\u04df\u04e1\u0007\u0099\u0002\u0002\u04e0\u04df',
-  '\u0003\u0002\u0002\u0002\u04e0\u04e1\u0003\u0002\u0002\u0002\u04e1\u04e2',
-  '\u0003\u0002\u0002\u0002\u04e2\u04e3\u0005\u0166\u00b4\u0002\u04e3\u04e4',
-  '\u0007\u0099\u0002\u0002\u04e4\u04e5\u0007Y\u0002\u0002\u04e5\u04e6',
-  '\u0007\u0099\u0002\u0002\u04e6\u04e8\u0005\u0102\u0082\u0002\u04e7\u04e9',
-  '\u0007\u0099\u0002\u0002\u04e8\u04e7\u0003\u0002\u0002\u0002\u04e8\u04e9',
-  '\u0003\u0002\u0002\u0002\u04e9\u04ea\u0003\u0002\u0002\u0002\u04ea\u04ed',
-  '\u0007\u0018\u0002\u0002\u04eb\u04ec\u0007\u0099\u0002\u0002\u04ec\u04ee',
-  '\u0005b2\u0002\u04ed\u04eb\u0003\u0002\u0002\u0002\u04ee\u04ef\u0003',
-  '\u0002\u0002\u0002\u04ef\u04ed\u0003\u0002\u0002\u0002\u04ef\u04f0\u0003',
-  '\u0002\u0002\u0002\u04f0\u04f2\u0003\u0002\u0002\u0002\u04f1\u04f3\u0007',
-  '\u0099\u0002\u0002\u04f2\u04f1\u0003\u0002\u0002\u0002\u04f2\u04f3\u0003',
-  '\u0002\u0002\u0002\u04f3\u04f4\u0003\u0002\u0002\u0002\u04f4\u04f5\u0007',
-  '\u0016\u0002\u0002\u04f5\u009f\u0003\u0002\u0002\u0002\u04f6\u04fb\u0007',
-  'K\u0002\u0002\u04f7\u04f9\u0007\u0099\u0002\u0002\u04f8\u04f7\u0003',
-  '\u0002\u0002\u0002\u04f8\u04f9\u0003\u0002\u0002\u0002\u04f9\u04fa\u0003',
-  '\u0002\u0002\u0002\u04fa\u04fc\u0007Z\u0002\u0002\u04fb\u04f8\u0003',
-  '\u0002\u0002\u0002\u04fb\u04fc\u0003\u0002\u0002\u0002\u04fc\u04fd\u0003',
-  '\u0002\u0002\u0002\u04fd\u04fe\u0007\u0099\u0002\u0002\u04fe\u0503\u0005',
-  '\u00a4S\u0002\u04ff\u0501\u0007\u0099\u0002\u0002\u0500\u04ff\u0003',
-  '\u0002\u0002\u0002\u0500\u0501\u0003\u0002\u0002\u0002\u0501\u0502\u0003',
-  '\u0002\u0002\u0002\u0502\u0504\u0005\u00d8m\u0002\u0503\u0500\u0003',
-  '\u0002\u0002\u0002\u0503\u0504\u0003\u0002\u0002\u0002\u0504\u00a1\u0003',
-  '\u0002\u0002\u0002\u0505\u050a\u0007[\u0002\u0002\u0506\u0508\u0007',
-  '\u0099\u0002\u0002\u0507\u0506\u0003\u0002\u0002\u0002\u0507\u0508\u0003',
-  '\u0002\u0002\u0002\u0508\u0509\u0003\u0002\u0002\u0002\u0509\u050b\u0007',
-  'Z\u0002\u0002\u050a\u0507\u0003\u0002\u0002\u0002\u050a\u050b\u0003',
-  '\u0002\u0002\u0002\u050b\u050d\u0003\u0002\u0002\u0002\u050c\u050e\u0007',
-  '\u0099\u0002\u0002\u050d\u050c\u0003\u0002\u0002\u0002\u050d\u050e\u0003',
-  '\u0002\u0002\u0002\u050e\u050f\u0003\u0002\u0002\u0002\u050f\u0510\u0005',
-  '\u00a4S\u0002\u0510\u00a3\u0003\u0002\u0002\u0002\u0511\u0514\u0005',
-  '\u00a6T\u0002\u0512\u0513\u0007\u0099\u0002\u0002\u0513\u0515\u0005',
-  '\u00bc_\u0002\u0514\u0512\u0003\u0002\u0002\u0002\u0514\u0515\u0003',
-  '\u0002\u0002\u0002\u0515\u0518\u0003\u0002\u0002\u0002\u0516\u0517\u0007',
-  '\u0099\u0002\u0002\u0517\u0519\u0005\u00be`\u0002\u0518\u0516\u0003',
-  '\u0002\u0002\u0002\u0518\u0519\u0003\u0002\u0002\u0002\u0519\u051c\u0003',
-  '\u0002\u0002\u0002\u051a\u051b\u0007\u0099\u0002\u0002\u051b\u051d\u0005',
-  '\u00c0a\u0002\u051c\u051a\u0003\u0002\u0002\u0002\u051c\u051d\u0003',
-  '\u0002\u0002\u0002\u051d\u00a5\u0003\u0002\u0002\u0002\u051e\u0529\u0007',
-  '\u0019\u0002\u0002\u051f\u0521\u0007\u0099\u0002\u0002\u0520\u051f\u0003',
-  '\u0002\u0002\u0002\u0520\u0521\u0003\u0002\u0002\u0002\u0521\u0522\u0003',
-  '\u0002\u0002\u0002\u0522\u0524\u0007\u0011\u0002\u0002\u0523\u0525\u0007',
-  '\u0099\u0002\u0002\u0524\u0523\u0003\u0002\u0002\u0002\u0524\u0525\u0003',
-  '\u0002\u0002\u0002\u0525\u0526\u0003\u0002\u0002\u0002\u0526\u0528\u0005',
-  '\u00a8U\u0002\u0527\u0520\u0003\u0002\u0002\u0002\u0528\u052b\u0003',
-  '\u0002\u0002\u0002\u0529\u0527\u0003\u0002\u0002\u0002\u0529\u052a\u0003',
-  '\u0002\u0002\u0002\u052a\u0542\u0003\u0002\u0002\u0002\u052b\u0529\u0003',
-  '\u0002\u0002\u0002\u052c\u0537\u0005\u00a8U\u0002\u052d\u052f\u0007',
-  '\u0099\u0002\u0002\u052e\u052d\u0003\u0002\u0002\u0002\u052e\u052f\u0003',
-  '\u0002\u0002\u0002\u052f\u0530\u0003\u0002\u0002\u0002\u0530\u0532\u0007',
-  '\u0011\u0002\u0002\u0531\u0533\u0007\u0099\u0002\u0002\u0532\u0531\u0003',
-  '\u0002\u0002\u0002\u0532\u0533\u0003\u0002\u0002\u0002\u0533\u0534\u0003',
-  '\u0002\u0002\u0002\u0534\u0536\u0005\u00a8U\u0002\u0535\u052e\u0003',
-  '\u0002\u0002\u0002\u0536\u0539\u0003\u0002\u0002\u0002\u0537\u0535\u0003',
-  '\u0002\u0002\u0002\u0537\u0538\u0003\u0002\u0002\u0002\u0538\u0542\u0003',
-  '\u0002\u0002\u0002\u0539\u0537\u0003\u0002\u0002\u0002\u053a\u053c\u0005',
-  '\u00acW\u0002\u053b\u053d\u0007\u0099\u0002\u0002\u053c\u053b\u0003',
-  '\u0002\u0002\u0002\u053c\u053d\u0003\u0002\u0002\u0002\u053d\u053f\u0003',
-  '\u0002\u0002\u0002\u053e\u0540\u0005\u00b2Z\u0002\u053f\u053e\u0003',
-  '\u0002\u0002\u0002\u053f\u0540\u0003\u0002\u0002\u0002\u0540\u0542\u0003',
-  '\u0002\u0002\u0002\u0541\u051e\u0003\u0002\u0002\u0002\u0541\u052c\u0003',
-  '\u0002\u0002\u0002\u0541\u053a\u0003\u0002\u0002\u0002\u0542\u00a7\u0003',
-  '\u0002\u0002\u0002\u0543\u0544\u0005\u0102\u0082\u0002\u0544\u0545\u0007',
-  '\u0099\u0002\u0002\u0545\u0546\u0007N\u0002\u0002\u0546\u0547\u0007',
-  '\u0099\u0002\u0002\u0547\u0548\u0005\u0166\u00b4\u0002\u0548\u054b\u0003',
-  '\u0002\u0002\u0002\u0549\u054b\u0005\u0102\u0082\u0002\u054a\u0543\u0003',
-  '\u0002\u0002\u0002\u054a\u0549\u0003\u0002\u0002\u0002\u054b\u00a9\u0003',
-  '\u0002\u0002\u0002\u054c\u054d\u0007\u0083\u0002\u0002\u054d\u054e\u0007',
-  '\u0099\u0002\u0002\u054e\u0550\u0005\u00acW\u0002\u054f\u0551\u0007',
-  '\u0099\u0002\u0002\u0550\u054f\u0003\u0002\u0002\u0002\u0550\u0551\u0003',
-  '\u0002\u0002\u0002\u0551\u0553\u0003\u0002\u0002\u0002\u0552\u0554\u0005',
-  '\u00b2Z\u0002\u0553\u0552\u0003\u0002\u0002\u0002\u0553\u0554\u0003',
-  '\u0002\u0002\u0002\u0554\u00ab\u0003\u0002\u0002\u0002\u0555\u0557\u0005',
-  '\u00aeX\u0002\u0556\u0558\u0007\u0099\u0002\u0002\u0557\u0556\u0003',
-  '\u0002\u0002\u0002\u0557\u0558\u0003\u0002\u0002\u0002\u0558\u055a\u0003',
-  '\u0002\u0002\u0002\u0559\u055b\u0005\u00b0Y\u0002\u055a\u0559\u0003',
-  '\u0002\u0002\u0002\u055a\u055b\u0003\u0002\u0002\u0002\u055b\u00ad\u0003',
-  '\u0002\u0002\u0002\u055c\u055d\u0005\u018c\u00c7\u0002\u055d\u055e\u0005',
-  '\u015a\u00ae\u0002\u055e\u00af\u0003\u0002\u0002\u0002\u055f\u0561\u0007',
-  '\u0015\u0002\u0002\u0560\u0562\u0007\u0099\u0002\u0002\u0561\u0560\u0003',
-  '\u0002\u0002\u0002\u0561\u0562\u0003\u0002\u0002\u0002\u0562\u0564\u0003',
-  '\u0002\u0002\u0002\u0563\u0565\u0005\u0102\u0082\u0002\u0564\u0563\u0003',
-  '\u0002\u0002\u0002\u0564\u0565\u0003\u0002\u0002\u0002\u0565\u0570\u0003',
-  '\u0002\u0002\u0002\u0566\u0568\u0007\u0099\u0002\u0002\u0567\u0566\u0003',
-  '\u0002\u0002\u0002\u0567\u0568\u0003\u0002\u0002\u0002\u0568\u0569\u0003',
-  '\u0002\u0002\u0002\u0569\u056b\u0007\u0011\u0002\u0002\u056a\u056c\u0007',
-  '\u0099\u0002\u0002\u056b\u056a\u0003\u0002\u0002\u0002\u056b\u056c\u0003',
-  '\u0002\u0002\u0002\u056c\u056d\u0003\u0002\u0002\u0002\u056d\u056f\u0005',
-  '\u0102\u0082\u0002\u056e\u0567\u0003\u0002\u0002\u0002\u056f\u0572\u0003',
-  '\u0002\u0002\u0002\u0570\u056e\u0003\u0002\u0002\u0002\u0570\u0571\u0003',
-  '\u0002\u0002\u0002\u0571\u0574\u0003\u0002\u0002\u0002\u0572\u0570\u0003',
-  '\u0002\u0002\u0002\u0573\u0575\u0007\u0099\u0002\u0002\u0574\u0573\u0003',
-  '\u0002\u0002\u0002\u0574\u0575\u0003\u0002\u0002\u0002\u0575\u0576\u0003',
-  '\u0002\u0002\u0002\u0576\u0577\u0007\u0016\u0002\u0002\u0577\u00b1\u0003',
-  '\u0002\u0002\u0002\u0578\u0579\u0007\u0084\u0002\u0002\u0579\u057a\u0007',
-  '\u0099\u0002\u0002\u057a\u0585\u0005\u00b4[\u0002\u057b\u057d\u0007',
-  '\u0099\u0002\u0002\u057c\u057b\u0003\u0002\u0002\u0002\u057c\u057d\u0003',
-  '\u0002\u0002\u0002\u057d\u057e\u0003\u0002\u0002\u0002\u057e\u0580\u0007',
-  '\u0011\u0002\u0002\u057f\u0581\u0007\u0099\u0002\u0002\u0580\u057f\u0003',
-  '\u0002\u0002\u0002\u0580\u0581\u0003\u0002\u0002\u0002\u0581\u0582\u0003',
-  '\u0002\u0002\u0002\u0582\u0584\u0005\u00b4[\u0002\u0583\u057c\u0003',
-  '\u0002\u0002\u0002\u0584\u0587\u0003\u0002\u0002\u0002\u0585\u0583\u0003',
-  '\u0002\u0002\u0002\u0585\u0586\u0003\u0002\u0002\u0002\u0586\u058a\u0003',
-  '\u0002\u0002\u0002\u0587\u0585\u0003\u0002\u0002\u0002\u0588\u0589\u0007',
-  '\u0099\u0002\u0002\u0589\u058b\u0005\u00d8m\u0002\u058a\u0588\u0003',
-  '\u0002\u0002\u0002\u058a\u058b\u0003\u0002\u0002\u0002\u058b\u00b3\u0003',
-  '\u0002\u0002\u0002\u058c\u058f\u0005\u00b6\\\u0002\u058d\u058f\u0005',
-  '\u00b8]\u0002\u058e\u058c\u0003\u0002\u0002\u0002\u058e\u058d\u0003',
-  '\u0002\u0002\u0002\u058f\u00b5\u0003\u0002\u0002\u0002\u0590\u0591\u0005',
-  '\u00ba^\u0002\u0591\u0592\u0007\u0099\u0002\u0002\u0592\u0593\u0007',
-  'N\u0002\u0002\u0593\u0594\u0007\u0099\u0002\u0002\u0594\u0595\u0005',
-  '\u0166\u00b4\u0002\u0595\u00b7\u0003\u0002\u0002\u0002\u0596\u0597\u0005',
-  '\u00ba^\u0002\u0597\u00b9\u0003\u0002\u0002\u0002\u0598\u0599\u0005',
-  '\u0194\u00cb\u0002\u0599\u00bb\u0003\u0002\u0002\u0002\u059a\u059b\u0007',
-  '\\\u0002\u0002\u059b\u059c\u0007\u0099\u0002\u0002\u059c\u059d\u0007',
-  ']\u0002\u0002\u059d\u059e\u0007\u0099\u0002\u0002\u059e\u05a9\u0005',
-  '\u00c2b\u0002\u059f\u05a1\u0007\u0099\u0002\u0002\u05a0\u059f\u0003',
-  '\u0002\u0002\u0002\u05a0\u05a1\u0003\u0002\u0002\u0002\u05a1\u05a2\u0003',
-  '\u0002\u0002\u0002\u05a2\u05a4\u0007\u0011\u0002\u0002\u05a3\u05a5\u0007',
-  '\u0099\u0002\u0002\u05a4\u05a3\u0003\u0002\u0002\u0002\u05a4\u05a5\u0003',
-  '\u0002\u0002\u0002\u05a5\u05a6\u0003\u0002\u0002\u0002\u05a6\u05a8\u0005',
-  '\u00c2b\u0002\u05a7\u05a0\u0003\u0002\u0002\u0002\u05a8\u05ab\u0003',
-  '\u0002\u0002\u0002\u05a9\u05a7\u0003\u0002\u0002\u0002\u05a9\u05aa\u0003',
-  '\u0002\u0002\u0002\u05aa\u00bd\u0003\u0002\u0002\u0002\u05ab\u05a9\u0003',
-  '\u0002\u0002\u0002\u05ac\u05ad\u0007^\u0002\u0002\u05ad\u05ae\u0007',
-  '\u0099\u0002\u0002\u05ae\u05af\u0005\u0102\u0082\u0002\u05af\u00bf\u0003',
-  '\u0002\u0002\u0002\u05b0\u05b1\u0007_\u0002\u0002\u05b1\u05b2\u0007',
-  '\u0099\u0002\u0002\u05b2\u05b3\u0005\u0102\u0082\u0002\u05b3\u00c1\u0003',
-  '\u0002\u0002\u0002\u05b4\u05bc\u0005\u0102\u0082\u0002\u05b5\u05b7\u0007',
-  '\u0099\u0002\u0002\u05b6\u05b5\u0003\u0002\u0002\u0002\u05b6\u05b7\u0003',
-  '\u0002\u0002\u0002\u05b7\u05b8\u0003\u0002\u0002\u0002\u05b8\u05ba\t',
-  '\u0003\u0002\u0002\u05b9\u05bb\u0007\u0099\u0002\u0002\u05ba\u05b9\u0003',
-  '\u0002\u0002\u0002\u05ba\u05bb\u0003\u0002\u0002\u0002\u05bb\u05bd\u0003',
-  '\u0002\u0002\u0002\u05bc\u05b6\u0003\u0002\u0002\u0002\u05bc\u05bd\u0003',
-  '\u0002\u0002\u0002\u05bd\u00c3\u0003\u0002\u0002\u0002\u05be\u05c0\u0007',
-  '\u0099\u0002\u0002\u05bf\u05be\u0003\u0002\u0002\u0002\u05bf\u05c0\u0003',
-  '\u0002\u0002\u0002\u05c0\u05ef\u0003\u0002\u0002\u0002\u05c1\u05c2\u0007',
-  ';\u0002\u0002\u05c2\u05c3\u0007\u0099\u0002\u0002\u05c3\u05c4\u0007',
-  'B\u0002\u0002\u05c4\u05c5\u0007\u0099\u0002\u0002\u05c5\u05c6\u0005',
-  '\u0166\u00b4\u0002\u05c6\u05c8\u0005\u00fa~\u0002\u05c7\u05c9\u0007',
-  '\u0099\u0002\u0002\u05c8\u05c7\u0003\u0002\u0002\u0002\u05c8\u05c9\u0003',
-  '\u0002\u0002\u0002\u05c9\u05ca\u0003\u0002\u0002\u0002\u05ca\u05cc\u0007',
-  '\u0015\u0002\u0002\u05cb\u05cd\u0007\u0099\u0002\u0002\u05cc\u05cb\u0003',
-  '\u0002\u0002\u0002\u05cc\u05cd\u0003\u0002\u0002\u0002\u05cd\u05ce\u0003',
-  '\u0002\u0002\u0002\u05ce\u05d0\u0005\u0184\u00c3\u0002\u05cf\u05d1\u0007',
-  '\u0099\u0002\u0002\u05d0\u05cf\u0003\u0002\u0002\u0002\u05d0\u05d1\u0003',
-  '\u0002\u0002\u0002\u05d1\u05d2\u0003\u0002\u0002\u0002\u05d2\u05d3\u0007',
-  '\u0016\u0002\u0002\u05d3\u05f0\u0003\u0002\u0002\u0002\u05d4\u05d5\u0007',
-  ';\u0002\u0002\u05d5\u05d6\u0007\u0099\u0002\u0002\u05d6\u05d7\u0007',
-  'd\u0002\u0002\u05d7\u05d8\u0007\u0099\u0002\u0002\u05d8\u05d9\u0007',
-  'C\u0002\u0002\u05d9\u05da\u0007\u0099\u0002\u0002\u05da\u05e5\u0005',
-  '\u0166\u00b4\u0002\u05db\u05dd\u0007\u0099\u0002\u0002\u05dc\u05db\u0003',
-  '\u0002\u0002\u0002\u05dc\u05dd\u0003\u0002\u0002\u0002\u05dd\u05de\u0003',
-  '\u0002\u0002\u0002\u05de\u05e0\u0007\u0011\u0002\u0002\u05df\u05e1\u0007',
-  '\u0099\u0002\u0002\u05e0\u05df\u0003\u0002\u0002\u0002\u05e0\u05e1\u0003',
-  '\u0002\u0002\u0002\u05e1\u05e2\u0003\u0002\u0002\u0002\u05e2\u05e4\u0005',
-  '\u0166\u00b4\u0002\u05e3\u05dc\u0003\u0002\u0002\u0002\u05e4\u05e7\u0003',
-  '\u0002\u0002\u0002\u05e5\u05e3\u0003\u0002\u0002\u0002\u05e5\u05e6\u0003',
-  '\u0002\u0002\u0002\u05e6\u05f0\u0003\u0002\u0002\u0002\u05e7\u05e5\u0003',
-  '\u0002\u0002\u0002\u05e8\u05e9\u0007;\u0002\u0002\u05e9\u05ea\u0007',
-  '\u0099\u0002\u0002\u05ea\u05eb\u0007e\u0002\u0002\u05eb\u05ec\u0007',
-  '\u0099\u0002\u0002\u05ec\u05ed\u0005\u0166\u00b4\u0002\u05ed\u05ee\u0005',
-  '\u00fa~\u0002\u05ee\u05f0\u0003\u0002\u0002\u0002\u05ef\u05c1\u0003',
-  '\u0002\u0002\u0002\u05ef\u05d4\u0003\u0002\u0002\u0002\u05ef\u05e8\u0003',
-  '\u0002\u0002\u0002\u05f0\u00c5\u0003\u0002\u0002\u0002\u05f1\u05f2\u0007',
-  'f\u0002\u0002\u05f2\u05f3\u0007\u0099\u0002\u0002\u05f3\u05fe\u0005',
-  '\u00c8e\u0002\u05f4\u05f6\u0007\u0099\u0002\u0002\u05f5\u05f4\u0003',
-  '\u0002\u0002\u0002\u05f5\u05f6\u0003\u0002\u0002\u0002\u05f6\u05f7\u0003',
-  '\u0002\u0002\u0002\u05f7\u05f9\u0007\u0011\u0002\u0002\u05f8\u05fa\u0007',
-  '\u0099\u0002\u0002\u05f9\u05f8\u0003\u0002\u0002\u0002\u05f9\u05fa\u0003',
-  '\u0002\u0002\u0002\u05fa\u05fb\u0003\u0002\u0002\u0002\u05fb\u05fd\u0005',
-  '\u00c8e\u0002\u05fc\u05f5\u0003\u0002\u0002\u0002\u05fd\u0600\u0003',
-  '\u0002\u0002\u0002\u05fe\u05fc\u0003\u0002\u0002\u0002\u05fe\u05ff\u0003',
-  '\u0002\u0002\u0002\u05ff\u0602\u0003\u0002\u0002\u0002\u0600\u05fe\u0003',
-  '\u0002\u0002\u0002\u0601\u0603\u0005\u00d8m\u0002\u0602\u0601\u0003',
-  '\u0002\u0002\u0002\u0602\u0603\u0003\u0002\u0002\u0002\u0603\u00c7\u0003',
-  '\u0002\u0002\u0002\u0604\u0606\u0005\u0166\u00b4\u0002\u0605\u0607\u0007',
-  '\u0099\u0002\u0002\u0606\u0605\u0003\u0002\u0002\u0002\u0606\u0607\u0003',
-  '\u0002\u0002\u0002\u0607\u0608\u0003\u0002\u0002\u0002\u0608\u060a\u0007',
-  '\u000e\u0002\u0002\u0609\u060b\u0007\u0099\u0002\u0002\u060a\u0609\u0003',
-  '\u0002\u0002\u0002\u060a\u060b\u0003\u0002\u0002\u0002\u060b\u060c\u0003',
-  '\u0002\u0002\u0002\u060c\u060d\u0005\u00caf\u0002\u060d\u00c9\u0003',
-  '\u0002\u0002\u0002\u060e\u0611\u0005\u00ccg\u0002\u060f\u0611\u0005',
-  '\u00ceh\u0002\u0610\u060e\u0003\u0002\u0002\u0002\u0610\u060f\u0003',
-  '\u0002\u0002\u0002\u0611\u00cb\u0003\u0002\u0002\u0002\u0612\u0614\u0007',
-  'g\u0002\u0002\u0613\u0615\u0007\u0099\u0002\u0002\u0614\u0613\u0003',
-  '\u0002\u0002\u0002\u0614\u0615\u0003\u0002\u0002\u0002\u0615\u0619\u0003',
-  '\u0002\u0002\u0002\u0616\u061a\u0005\u00d0i\u0002\u0617\u061a\u0005',
-  '\u00d2j\u0002\u0618\u061a\u0005\u00d4k\u0002\u0619\u0616\u0003\u0002',
-  '\u0002\u0002\u0619\u0617\u0003\u0002\u0002\u0002\u0619\u0618\u0003\u0002',
-  '\u0002\u0002\u061a\u00cd\u0003\u0002\u0002\u0002\u061b\u061f\t\u0004',
-  '\u0002\u0002\u061c\u0620\u0005\u00d0i\u0002\u061d\u0620\u0005\u00d2',
-  'j\u0002\u061e\u0620\u0005\u00d4k\u0002\u061f\u061c\u0003\u0002\u0002',
-  '\u0002\u061f\u061d\u0003\u0002\u0002\u0002\u061f\u061e\u0003\u0002\u0002',
-  '\u0002\u0620\u00cf\u0003\u0002\u0002\u0002\u0621\u0622\u0007\u0004\u0002',
-  '\u0002\u0622\u0623\u0005\u0194\u00cb\u0002\u0623\u0624\u0007\u0015\u0002',
-  '\u0002\u0624\u0625\u0005\u0194\u00cb\u0002\u0625\u0628\u0007\u000e\u0002',
-  '\u0002\u0626\u0629\u0007\u0086\u0002\u0002\u0627\u0629\u0005\u0178\u00bd',
-  '\u0002\u0628\u0626\u0003\u0002\u0002\u0002\u0628\u0627\u0003\u0002\u0002',
-  '\u0002\u0629\u062a\u0003\u0002\u0002\u0002\u062a\u062b\u0007\u0016\u0002',
-  '\u0002\u062b\u00d1\u0003\u0002\u0002\u0002\u062c\u062d\u0007\u0004\u0002',
-  '\u0002\u062d\u062e\u0005\u0194\u00cb\u0002\u062e\u0631\u0007\u0015\u0002',
-  '\u0002\u062f\u0632\u0007\u0086\u0002\u0002\u0630\u0632\u0005\u0178\u00bd',
-  '\u0002\u0631\u062f\u0003\u0002\u0002\u0002\u0631\u0630\u0003\u0002\u0002',
-  '\u0002\u0632\u0633\u0003\u0002\u0002\u0002\u0633\u0634\u0007\u0016\u0002',
-  '\u0002\u0634\u00d3\u0003\u0002\u0002\u0002\u0635\u0639\u0007\u0015\u0002',
-  '\u0002\u0636\u063a\u0005\u00d6l\u0002\u0637\u063a\u0005\u0178\u00bd',
-  '\u0002\u0638\u063a\u0007\u0019\u0002\u0002\u0639\u0636\u0003\u0002\u0002',
-  '\u0002\u0639\u0637\u0003\u0002\u0002\u0002\u0639\u0638\u0003\u0002\u0002',
-  '\u0002\u063a\u063b\u0003\u0002\u0002\u0002\u063b\u063c\u0007\u0016\u0002',
-  '\u0002\u063c\u00d5\u0003\u0002\u0002\u0002\u063d\u0648\u0005\u0188\u00c5',
-  '\u0002\u063e\u0640\u0007\u0099\u0002\u0002\u063f\u063e\u0003\u0002\u0002',
-  '\u0002\u063f\u0640\u0003\u0002\u0002\u0002\u0640\u0641\u0003\u0002\u0002',
-  '\u0002\u0641\u0643\u0007\u0011\u0002\u0002\u0642\u0644\u0007\u0099\u0002',
-  '\u0002\u0643\u0642\u0003\u0002\u0002\u0002\u0643\u0644\u0003\u0002\u0002',
-  '\u0002\u0644\u0645\u0003\u0002\u0002\u0002\u0645\u0647\u0005\u0188\u00c5',
-  '\u0002\u0646\u063f\u0003\u0002\u0002\u0002\u0647\u064a\u0003\u0002\u0002',
-  '\u0002\u0648\u0646\u0003\u0002\u0002\u0002\u0648\u0649\u0003\u0002\u0002',
-  '\u0002\u0649\u00d7\u0003\u0002\u0002\u0002\u064a\u0648\u0003\u0002\u0002',
-  '\u0002\u064b\u064c\u0007j\u0002\u0002\u064c\u064d\u0007\u0099\u0002',
-  '\u0002\u064d\u064e\u0005\u0102\u0082\u0002\u064e\u00d9\u0003\u0002\u0002',
-  '\u0002\u064f\u065a\u0005\u00dco\u0002\u0650\u0652\u0007\u0099\u0002',
-  '\u0002\u0651\u0650\u0003\u0002\u0002\u0002\u0651\u0652\u0003\u0002\u0002',
-  '\u0002\u0652\u0653\u0003\u0002\u0002\u0002\u0653\u0655\u0007\u0011\u0002',
-  '\u0002\u0654\u0656\u0007\u0099\u0002\u0002\u0655\u0654\u0003\u0002\u0002',
-  '\u0002\u0655\u0656\u0003\u0002\u0002\u0002\u0656\u0657\u0003\u0002\u0002',
-  '\u0002\u0657\u0659\u0005\u00dco\u0002\u0658\u0651\u0003\u0002\u0002',
-  '\u0002\u0659\u065c\u0003\u0002\u0002\u0002\u065a\u0658\u0003\u0002\u0002',
-  '\u0002\u065a\u065b\u0003\u0002\u0002\u0002\u065b\u00db\u0003\u0002\u0002',
-  '\u0002\u065c\u065a\u0003\u0002\u0002\u0002\u065d\u065f\u0005\u0166\u00b4',
-  '\u0002\u065e\u0660\u0007\u0099\u0002\u0002\u065f\u065e\u0003\u0002\u0002',
-  '\u0002\u065f\u0660\u0003\u0002\u0002\u0002\u0660\u0661\u0003\u0002\u0002',
-  '\u0002\u0661\u0663\u0007\u000e\u0002\u0002\u0662\u0664\u0007\u0099\u0002',
-  '\u0002\u0663\u0662\u0003\u0002\u0002\u0002\u0663\u0664\u0003\u0002\u0002',
-  '\u0002\u0664\u0665\u0003\u0002\u0002\u0002\u0665\u0666\u0005\u00dep',
-  '\u0002\u0666\u0669\u0003\u0002\u0002\u0002\u0667\u0669\u0005\u00dep',
-  '\u0002\u0668\u065d\u0003\u0002\u0002\u0002\u0668\u0667\u0003\u0002\u0002',
-  '\u0002\u0669\u00dd\u0003\u0002\u0002\u0002\u066a\u066d\u0005\u013a\u009e',
-  '\u0002\u066b\u066d\u0005\u00e0q\u0002\u066c\u066a\u0003\u0002\u0002',
-  '\u0002\u066c\u066b\u0003\u0002\u0002\u0002\u066d\u00df\u0003\u0002\u0002',
-  '\u0002\u066e\u0675\u0005\u00e2r\u0002\u066f\u0671\u0007\u0099\u0002',
-  '\u0002\u0670\u066f\u0003\u0002\u0002\u0002\u0670\u0671\u0003\u0002\u0002',
-  '\u0002\u0671\u0672\u0003\u0002\u0002\u0002\u0672\u0674\u0005\u00e4s',
-  '\u0002\u0673\u0670\u0003\u0002\u0002\u0002\u0674\u0677\u0003\u0002\u0002',
-  '\u0002\u0675\u0673\u0003\u0002\u0002\u0002\u0675\u0676\u0003\u0002\u0002',
-  '\u0002\u0676\u067d\u0003\u0002\u0002\u0002\u0677\u0675\u0003\u0002\u0002',
-  '\u0002\u0678\u0679\u0007\u0015\u0002\u0002\u0679\u067a\u0005\u00e0q',
-  '\u0002\u067a\u067b\u0007\u0016\u0002\u0002\u067b\u067d\u0003\u0002\u0002',
-  '\u0002\u067c\u066e\u0003\u0002\u0002\u0002\u067c\u0678\u0003\u0002\u0002',
-  '\u0002\u067d\u00e1\u0003\u0002\u0002\u0002\u067e\u0680\u0007\u0015\u0002',
-  '\u0002\u067f\u0681\u0007\u0099\u0002\u0002\u0680\u067f\u0003\u0002\u0002',
-  '\u0002\u0680\u0681\u0003\u0002\u0002\u0002\u0681\u0686\u0003\u0002\u0002',
-  '\u0002\u0682\u0684\u0005\u0166\u00b4\u0002\u0683\u0685\u0007\u0099\u0002',
-  '\u0002\u0684\u0683\u0003\u0002\u0002\u0002\u0684\u0685\u0003\u0002\u0002',
-  '\u0002\u0685\u0687\u0003\u0002\u0002\u0002\u0686\u0682\u0003\u0002\u0002',
-  '\u0002\u0686\u0687\u0003\u0002\u0002\u0002\u0687\u068c\u0003\u0002\u0002',
-  '\u0002\u0688\u068a\u0005\u00f8}\u0002\u0689\u068b\u0007\u0099\u0002',
-  '\u0002\u068a\u0689\u0003\u0002\u0002\u0002\u068a\u068b\u0003\u0002\u0002',
-  '\u0002\u068b\u068d\u0003\u0002\u0002\u0002\u068c\u0688\u0003\u0002\u0002',
-  '\u0002\u068c\u068d\u0003\u0002\u0002\u0002\u068d\u0692\u0003\u0002\u0002',
-  '\u0002\u068e\u0690\u0005\u00eex\u0002\u068f\u0691\u0007\u0099\u0002',
-  '\u0002\u0690\u068f\u0003\u0002\u0002\u0002\u0690\u0691\u0003\u0002\u0002',
-  '\u0002\u0691\u0693\u0003\u0002\u0002\u0002\u0692\u068e\u0003\u0002\u0002',
-  '\u0002\u0692\u0693\u0003\u0002\u0002\u0002\u0693\u0694\u0003\u0002\u0002',
-  '\u0002\u0694\u0695\u0007\u0016\u0002\u0002\u0695\u00e3\u0003\u0002\u0002',
-  '\u0002\u0696\u0698\u0005\u00e6t\u0002\u0697\u0699\u0007\u0099\u0002',
-  '\u0002\u0698\u0697\u0003\u0002\u0002\u0002\u0698\u0699\u0003\u0002\u0002',
-  '\u0002\u0699\u069a\u0003\u0002\u0002\u0002\u069a\u069b\u0005\u00e2r',
-  '\u0002\u069b\u00e5\u0003\u0002\u0002\u0002\u069c\u069e\u0005\u00e8u',
-  '\u0002\u069d\u069f\u0007\u0099\u0002\u0002\u069e\u069d\u0003\u0002\u0002',
-  '\u0002\u069e\u069f\u0003\u0002\u0002\u0002\u069f\u06a1\u0003\u0002\u0002',
-  '\u0002\u06a0\u06a2\u0005\u00ecw\u0002\u06a1\u06a0\u0003\u0002\u0002',
-  '\u0002\u06a1\u06a2\u0003\u0002\u0002\u0002\u06a2\u06a4\u0003\u0002\u0002',
-  '\u0002\u06a3\u06a5\u0007\u0099\u0002\u0002\u06a4\u06a3\u0003\u0002\u0002',
-  '\u0002\u06a4\u06a5\u0003\u0002\u0002\u0002\u06a5\u06a6\u0003\u0002\u0002',
-  '\u0002\u06a6\u06a7\u0005\u00eav\u0002\u06a7\u00e7\u0003\u0002\u0002',
-  '\u0002\u06a8\u06aa\u0005\u018e\u00c8\u0002\u06a9\u06ab\u0007\u0099\u0002',
-  '\u0002\u06aa\u06a9\u0003\u0002\u0002\u0002\u06aa\u06ab\u0003\u0002\u0002',
-  '\u0002\u06ab\u06ac\u0003\u0002\u0002\u0002\u06ac\u06ad\u0005\u0192\u00ca',
-  '\u0002\u06ad\u06b0\u0003\u0002\u0002\u0002\u06ae\u06b0\u0005\u0192\u00ca',
-  '\u0002\u06af\u06a8\u0003\u0002\u0002\u0002\u06af\u06ae\u0003\u0002\u0002',
-  '\u0002\u06b0\u00e9\u0003\u0002\u0002\u0002\u06b1\u06b3\u0005\u0192\u00ca',
-  '\u0002\u06b2\u06b4\u0007\u0099\u0002\u0002\u06b3\u06b2\u0003\u0002\u0002',
-  '\u0002\u06b3\u06b4\u0003\u0002\u0002\u0002\u06b4\u06b5\u0003\u0002\u0002',
-  '\u0002\u06b5\u06b6\u0005\u0190\u00c9\u0002\u06b6\u06b9\u0003\u0002\u0002',
-  '\u0002\u06b7\u06b9\u0005\u0192\u00ca\u0002\u06b8\u06b1\u0003\u0002\u0002',
-  '\u0002\u06b8\u06b7\u0003\u0002\u0002\u0002\u06b9\u00eb\u0003\u0002\u0002',
-  '\u0002\u06ba\u06bc\u0007\u0013\u0002\u0002\u06bb\u06bd\u0007\u0099\u0002',
-  '\u0002\u06bc\u06bb\u0003\u0002\u0002\u0002\u06bc\u06bd\u0003\u0002\u0002',
-  '\u0002\u06bd\u06c2\u0003\u0002\u0002\u0002\u06be\u06c0\u0005\u0166\u00b4',
-  '\u0002\u06bf\u06c1\u0007\u0099\u0002\u0002\u06c0\u06bf\u0003\u0002\u0002',
-  '\u0002\u06c0\u06c1\u0003\u0002\u0002\u0002\u06c1\u06c3\u0003\u0002\u0002',
-  '\u0002\u06c2\u06be\u0003\u0002\u0002\u0002\u06c2\u06c3\u0003\u0002\u0002',
-  '\u0002\u06c3\u06c8\u0003\u0002\u0002\u0002\u06c4\u06c6\u0005\u00f2z',
-  '\u0002\u06c5\u06c7\u0007\u0099\u0002\u0002\u06c6\u06c5\u0003\u0002\u0002',
-  '\u0002\u06c6\u06c7\u0003\u0002\u0002\u0002\u06c7\u06c9\u0003\u0002\u0002',
-  '\u0002\u06c8\u06c4\u0003\u0002\u0002\u0002\u06c8\u06c9\u0003\u0002\u0002',
-  '\u0002\u06c9\u06cb\u0003\u0002\u0002\u0002\u06ca\u06cc\u0005\u00fc\u007f',
-  '\u0002\u06cb\u06ca\u0003\u0002\u0002\u0002\u06cb\u06cc\u0003\u0002\u0002',
-  '\u0002\u06cc\u06d1\u0003\u0002\u0002\u0002\u06cd\u06cf\u0005\u00eex',
-  '\u0002\u06ce\u06d0\u0007\u0099\u0002\u0002\u06cf\u06ce\u0003\u0002\u0002',
-  '\u0002\u06cf\u06d0\u0003\u0002\u0002\u0002\u06d0\u06d2\u0003\u0002\u0002',
-  '\u0002\u06d1\u06cd\u0003\u0002\u0002\u0002\u06d1\u06d2\u0003\u0002\u0002',
-  '\u0002\u06d2\u06d3\u0003\u0002\u0002\u0002\u06d3\u06d4\u0007\u0014\u0002',
-  '\u0002\u06d4\u00ed\u0003\u0002\u0002\u0002\u06d5\u06d8\u0005\u016a\u00b6',
-  '\u0002\u06d6\u06d8\u0005\u0178\u00bd\u0002\u06d7\u06d5\u0003\u0002\u0002',
-  '\u0002\u06d7\u06d6\u0003\u0002\u0002\u0002\u06d8\u00ef\u0003\u0002\u0002',
-  '\u0002\u06d9\u06db\u0007\u0004\u0002\u0002\u06da\u06dc\u0007\u0099\u0002',
-  '\u0002\u06db\u06da\u0003\u0002\u0002\u0002\u06db\u06dc\u0003\u0002\u0002',
-  '\u0002\u06dc\u06dd\u0003\u0002\u0002\u0002\u06dd\u06de\u0005\u0100\u0081',
-  '\u0002\u06de\u00f1\u0003\u0002\u0002\u0002\u06df\u06e7\u0005\u00f4{',
-  '\u0002\u06e0\u06e2\u0007\u0099\u0002\u0002\u06e1\u06e0\u0003\u0002\u0002',
-  '\u0002\u06e1\u06e2\u0003\u0002\u0002\u0002\u06e2\u06e3\u0003\u0002\u0002',
-  '\u0002\u06e3\u06e4\u0007\u0018\u0002\u0002\u06e4\u06e6\u0005\u00f6|',
-  '\u0002\u06e5\u06e1\u0003\u0002\u0002\u0002\u06e6\u06e9\u0003\u0002\u0002',
-  '\u0002\u06e7\u06e5\u0003\u0002\u0002\u0002\u06e7\u06e8\u0003\u0002\u0002',
-  '\u0002\u06e8\u00f3\u0003\u0002\u0002\u0002\u06e9\u06e7\u0003\u0002\u0002',
-  '\u0002\u06ea\u06eb\u0007\u0004\u0002\u0002\u06eb\u06ec\u0005\u0100\u0081',
-  '\u0002\u06ec\u00f5\u0003\u0002\u0002\u0002\u06ed\u06ef\u0007\u0004\u0002',
-  '\u0002\u06ee\u06ed\u0003\u0002\u0002\u0002\u06ee\u06ef\u0003\u0002\u0002',
-  '\u0002\u06ef\u06f0\u0003\u0002\u0002\u0002\u06f0\u06f1\u0005\u0100\u0081',
-  '\u0002\u06f1\u00f7\u0003\u0002\u0002\u0002\u06f2\u06f9\u0005\u00fa~',
-  '\u0002\u06f3\u06f5\u0007\u0099\u0002\u0002\u06f4\u06f3\u0003\u0002\u0002',
-  '\u0002\u06f4\u06f5\u0003\u0002\u0002\u0002\u06f5\u06f6\u0003\u0002\u0002',
-  '\u0002\u06f6\u06f8\u0005\u00fa~\u0002\u06f7\u06f4\u0003\u0002\u0002',
-  '\u0002\u06f8\u06fb\u0003\u0002\u0002\u0002\u06f9\u06f7\u0003\u0002\u0002',
-  '\u0002\u06f9\u06fa\u0003\u0002\u0002\u0002\u06fa\u00f9\u0003\u0002\u0002',
-  '\u0002\u06fb\u06f9\u0003\u0002\u0002\u0002\u06fc\u06fd\u0007\u0004\u0002',
-  '\u0002\u06fd\u06fe\u0005\u00fe\u0080\u0002\u06fe\u00fb\u0003\u0002\u0002',
-  '\u0002\u06ff\u0701\u0007\u0019\u0002\u0002\u0700\u0702\u0007\u0099\u0002',
-  '\u0002\u0701\u0700\u0003\u0002\u0002\u0002\u0701\u0702\u0003\u0002\u0002',
-  '\u0002\u0702\u0707\u0003\u0002\u0002\u0002\u0703\u0705\u0005\u0188\u00c5',
-  '\u0002\u0704\u0706\u0007\u0099\u0002\u0002\u0705\u0704\u0003\u0002\u0002',
-  '\u0002\u0705\u0706\u0003\u0002\u0002\u0002\u0706\u0708\u0003\u0002\u0002',
-  '\u0002\u0707\u0703\u0003\u0002\u0002\u0002\u0707\u0708\u0003\u0002\u0002',
-  '\u0002\u0708\u0713\u0003\u0002\u0002\u0002\u0709\u070b\u0007\u001a\u0002',
-  '\u0002\u070a\u070c\u0007\u0099\u0002\u0002\u070b\u070a\u0003\u0002\u0002',
-  '\u0002\u070b\u070c\u0003\u0002\u0002\u0002\u070c\u0711\u0003\u0002\u0002',
-  '\u0002\u070d\u070f\u0005\u0188\u00c5\u0002\u070e\u0710\u0007\u0099\u0002',
-  '\u0002\u070f\u070e\u0003\u0002\u0002\u0002\u070f\u0710\u0003\u0002\u0002',
-  '\u0002\u0710\u0712\u0003\u0002\u0002\u0002\u0711\u070d\u0003\u0002\u0002',
-  '\u0002\u0711\u0712\u0003\u0002\u0002\u0002\u0712\u0714\u0003\u0002\u0002',
-  '\u0002\u0713\u0709\u0003\u0002\u0002\u0002\u0713\u0714\u0003\u0002\u0002',
-  '\u0002\u0714\u00fd\u0003\u0002\u0002\u0002\u0715\u0716\u0005\u0194\u00cb',
-  '\u0002\u0716\u00ff\u0003\u0002\u0002\u0002\u0717\u0718\u0005\u0194\u00cb',
-  '\u0002\u0718\u0101\u0003\u0002\u0002\u0002\u0719\u071a\u0005\u0104\u0083',
-  '\u0002\u071a\u0103\u0003\u0002\u0002\u0002\u071b\u0722\u0005\u0106\u0084',
-  '\u0002\u071c\u071d\u0007\u0099\u0002\u0002\u071d\u071e\u0007m\u0002',
-  '\u0002\u071e\u071f\u0007\u0099\u0002\u0002\u071f\u0721\u0005\u0106\u0084',
-  '\u0002\u0720\u071c\u0003\u0002\u0002\u0002\u0721\u0724\u0003\u0002\u0002',
-  '\u0002\u0722\u0720\u0003\u0002\u0002\u0002\u0722\u0723\u0003\u0002\u0002',
-  '\u0002\u0723\u0105\u0003\u0002\u0002\u0002\u0724\u0722\u0003\u0002\u0002',
-  '\u0002\u0725\u072c\u0005\u0108\u0085\u0002\u0726\u0727\u0007\u0099\u0002',
-  '\u0002\u0727\u0728\u0007n\u0002\u0002\u0728\u0729\u0007\u0099\u0002',
-  '\u0002\u0729\u072b\u0005\u0108\u0085\u0002\u072a\u0726\u0003\u0002\u0002',
-  '\u0002\u072b\u072e\u0003\u0002\u0002\u0002\u072c\u072a\u0003\u0002\u0002',
-  '\u0002\u072c\u072d\u0003\u0002\u0002\u0002\u072d\u0107\u0003\u0002\u0002',
-  '\u0002\u072e\u072c\u0003\u0002\u0002\u0002\u072f\u0736\u0005\u010a\u0086',
-  '\u0002\u0730\u0731\u0007\u0099\u0002\u0002\u0731\u0732\u0007o\u0002',
-  '\u0002\u0732\u0733\u0007\u0099\u0002\u0002\u0733\u0735\u0005\u010a\u0086',
-  '\u0002\u0734\u0730\u0003\u0002\u0002\u0002\u0735\u0738\u0003\u0002\u0002',
-  '\u0002\u0736\u0734\u0003\u0002\u0002\u0002\u0736\u0737\u0003\u0002\u0002',
-  '\u0002\u0737\u0109\u0003\u0002\u0002\u0002\u0738\u0736\u0003\u0002\u0002',
-  '\u0002\u0739\u073b\u0007p\u0002\u0002\u073a\u073c\u0007\u0099\u0002',
-  '\u0002\u073b\u073a\u0003\u0002\u0002\u0002\u073b\u073c\u0003\u0002\u0002',
-  '\u0002\u073c\u073e\u0003\u0002\u0002\u0002\u073d\u0739\u0003\u0002\u0002',
-  '\u0002\u073e\u0741\u0003\u0002\u0002\u0002\u073f\u073d\u0003\u0002\u0002',
-  '\u0002\u073f\u0740\u0003\u0002\u0002\u0002\u0740\u0742\u0003\u0002\u0002',
-  '\u0002\u0741\u073f\u0003\u0002\u0002\u0002\u0742\u0743\u0005\u010c\u0087',
-  '\u0002\u0743\u010b\u0003\u0002\u0002\u0002\u0744\u074b\u0005\u010e\u0088',
-  '\u0002\u0745\u0747\u0007\u0099\u0002\u0002\u0746\u0745\u0003\u0002\u0002',
-  '\u0002\u0746\u0747\u0003\u0002\u0002\u0002\u0747\u0748\u0003\u0002\u0002',
-  '\u0002\u0748\u074a\u0005\u014a\u00a6\u0002\u0749\u0746\u0003\u0002\u0002',
-  '\u0002\u074a\u074d\u0003\u0002\u0002\u0002\u074b\u0749\u0003\u0002\u0002',
-  '\u0002\u074b\u074c\u0003\u0002\u0002\u0002\u074c\u010d\u0003\u0002\u0002',
-  '\u0002\u074d\u074b\u0003\u0002\u0002\u0002\u074e\u0761\u0005\u0110\u0089',
-  '\u0002\u074f\u0751\u0007\u0099\u0002\u0002\u0750\u074f\u0003\u0002\u0002',
-  '\u0002\u0750\u0751\u0003\u0002\u0002\u0002\u0751\u0752\u0003\u0002\u0002',
-  '\u0002\u0752\u0754\u0007\u000f\u0002\u0002\u0753\u0755\u0007\u0099\u0002',
-  '\u0002\u0754\u0753\u0003\u0002\u0002\u0002\u0754\u0755\u0003\u0002\u0002',
-  '\u0002\u0755\u0756\u0003\u0002\u0002\u0002\u0756\u0760\u0005\u0110\u0089',
-  '\u0002\u0757\u0759\u0007\u0099\u0002\u0002\u0758\u0757\u0003\u0002\u0002',
-  '\u0002\u0758\u0759\u0003\u0002\u0002\u0002\u0759\u075a\u0003\u0002\u0002',
-  '\u0002\u075a\u075c\u0007\u0005\u0002\u0002\u075b\u075d\u0007\u0099\u0002',
-  '\u0002\u075c\u075b\u0003\u0002\u0002\u0002\u075c\u075d\u0003\u0002\u0002',
-  '\u0002\u075d\u075e\u0003\u0002\u0002\u0002\u075e\u0760\u0005\u0110\u0089',
-  '\u0002\u075f\u0750\u0003\u0002\u0002\u0002\u075f\u0758\u0003\u0002\u0002',
-  '\u0002\u0760\u0763\u0003\u0002\u0002\u0002\u0761\u075f\u0003\u0002\u0002',
-  '\u0002\u0761\u0762\u0003\u0002\u0002\u0002\u0762\u010f\u0003\u0002\u0002',
-  '\u0002\u0763\u0761\u0003\u0002\u0002\u0002\u0764\u077f\u0005\u0112\u008a',
-  '\u0002\u0765\u0767\u0007\u0099\u0002\u0002\u0766\u0765\u0003\u0002\u0002',
-  '\u0002\u0766\u0767\u0003\u0002\u0002\u0002\u0767\u0768\u0003\u0002\u0002',
-  '\u0002\u0768\u076a\u0007\u0019\u0002\u0002\u0769\u076b\u0007\u0099\u0002',
-  '\u0002\u076a\u0769\u0003\u0002\u0002\u0002\u076a\u076b\u0003\u0002\u0002',
-  '\u0002\u076b\u076c\u0003\u0002\u0002\u0002\u076c\u077e\u0005\u0112\u008a',
-  '\u0002\u076d\u076f\u0007\u0099\u0002\u0002\u076e\u076d\u0003\u0002\u0002',
-  '\u0002\u076e\u076f\u0003\u0002\u0002\u0002\u076f\u0770\u0003\u0002\u0002',
-  '\u0002\u0770\u0772\u0007\b\u0002\u0002\u0771\u0773\u0007\u0099\u0002',
-  '\u0002\u0772\u0771\u0003\u0002\u0002\u0002\u0772\u0773\u0003\u0002\u0002',
-  '\u0002\u0773\u0774\u0003\u0002\u0002\u0002\u0774\u077e\u0005\u0112\u008a',
-  '\u0002\u0775\u0777\u0007\u0099\u0002\u0002\u0776\u0775\u0003\u0002\u0002',
-  '\u0002\u0776\u0777\u0003\u0002\u0002\u0002\u0777\u0778\u0003\u0002\u0002',
-  '\u0002\u0778\u077a\u0007\u001b\u0002\u0002\u0779\u077b\u0007\u0099\u0002',
-  '\u0002\u077a\u0779\u0003\u0002\u0002\u0002\u077a\u077b\u0003\u0002\u0002',
-  '\u0002\u077b\u077c\u0003\u0002\u0002\u0002\u077c\u077e\u0005\u0112\u008a',
-  '\u0002\u077d\u0766\u0003\u0002\u0002\u0002\u077d\u076e\u0003\u0002\u0002',
-  '\u0002\u077d\u0776\u0003\u0002\u0002\u0002\u077e\u0781\u0003\u0002\u0002',
-  '\u0002\u077f\u077d\u0003\u0002\u0002\u0002\u077f\u0780\u0003\u0002\u0002',
-  '\u0002\u0780\u0111\u0003\u0002\u0002\u0002\u0781\u077f\u0003\u0002\u0002',
-  '\u0002\u0782\u078d\u0005\u0114\u008b\u0002\u0783\u0785\u0007\u0099\u0002',
-  '\u0002\u0784\u0783\u0003\u0002\u0002\u0002\u0784\u0785\u0003\u0002\u0002',
-  '\u0002\u0785\u0786\u0003\u0002\u0002\u0002\u0786\u0788\u0007\u001c\u0002',
-  '\u0002\u0787\u0789\u0007\u0099\u0002\u0002\u0788\u0787\u0003\u0002\u0002',
-  '\u0002\u0788\u0789\u0003\u0002\u0002\u0002\u0789\u078a\u0003\u0002\u0002',
-  '\u0002\u078a\u078c\u0005\u0114\u008b\u0002\u078b\u0784\u0003\u0002\u0002',
-  '\u0002\u078c\u078f\u0003\u0002\u0002\u0002\u078d\u078b\u0003\u0002\u0002',
-  '\u0002\u078d\u078e\u0003\u0002\u0002\u0002\u078e\u0113\u0003\u0002\u0002',
-  '\u0002\u078f\u078d\u0003\u0002\u0002\u0002\u0790\u0792\t\u0005\u0002',
-  '\u0002\u0791\u0793\u0007\u0099\u0002\u0002\u0792\u0791\u0003\u0002\u0002',
-  '\u0002\u0792\u0793\u0003\u0002\u0002\u0002\u0793\u0795\u0003\u0002\u0002',
-  '\u0002\u0794\u0790\u0003\u0002\u0002\u0002\u0795\u0798\u0003\u0002\u0002',
-  '\u0002\u0796\u0794\u0003\u0002\u0002\u0002\u0796\u0797\u0003\u0002\u0002',
-  '\u0002\u0797\u0799\u0003\u0002\u0002\u0002\u0798\u0796\u0003\u0002\u0002',
-  '\u0002\u0799\u079a\u0005\u0116\u008c\u0002\u079a\u0115\u0003\u0002\u0002',
-  '\u0002\u079b\u07d1\u0005\u0118\u008d\u0002\u079c\u079e\u0007\u0099\u0002',
-  '\u0002\u079d\u079c\u0003\u0002\u0002\u0002\u079d\u079e\u0003\u0002\u0002',
-  '\u0002\u079e\u079f\u0003\u0002\u0002\u0002\u079f\u07a0\u0007\u0013\u0002',
-  '\u0002\u07a0\u07a1\u0005\u0102\u0082\u0002\u07a1\u07a2\u0007\u0014\u0002',
-  '\u0002\u07a2\u07d0\u0003\u0002\u0002\u0002\u07a3\u07a5\u0007\u0099\u0002',
-  '\u0002\u07a4\u07a3\u0003\u0002\u0002\u0002\u07a4\u07a5\u0003\u0002\u0002',
-  '\u0002\u07a5\u07a6\u0003\u0002\u0002\u0002\u07a6\u07a8\u0007\u0013\u0002',
-  '\u0002\u07a7\u07a9\u0005\u0102\u0082\u0002\u07a8\u07a7\u0003\u0002\u0002',
-  '\u0002\u07a8\u07a9\u0003\u0002\u0002\u0002\u07a9\u07aa\u0003\u0002\u0002',
-  '\u0002\u07aa\u07ac\u0007\u001a\u0002\u0002\u07ab\u07ad\u0005\u0102\u0082',
-  '\u0002\u07ac\u07ab\u0003\u0002\u0002\u0002\u07ac\u07ad\u0003\u0002\u0002',
-  '\u0002\u07ad\u07ae\u0003\u0002\u0002\u0002\u07ae\u07d0\u0007\u0014\u0002',
-  '\u0002\u07af\u07b1\u0007\u0099\u0002\u0002\u07b0\u07af\u0003\u0002\u0002',
-  '\u0002\u07b0\u07b1\u0003\u0002\u0002\u0002\u07b1\u07b2\u0003\u0002\u0002',
-  '\u0002\u07b2\u07c0\u0007\u001d\u0002\u0002\u07b3\u07b4\u0007\u0099\u0002',
-  '\u0002\u07b4\u07c0\u0007Y\u0002\u0002\u07b5\u07b6\u0007\u0099\u0002',
-  '\u0002\u07b6\u07b7\u0007q\u0002\u0002\u07b7\u07b8\u0007\u0099\u0002',
-  '\u0002\u07b8\u07c0\u0007K\u0002\u0002\u07b9\u07ba\u0007\u0099\u0002',
-  '\u0002\u07ba\u07bb\u0007r\u0002\u0002\u07bb\u07bc\u0007\u0099\u0002',
-  '\u0002\u07bc\u07c0\u0007K\u0002\u0002\u07bd\u07be\u0007\u0099\u0002',
-  '\u0002\u07be\u07c0\u0007s\u0002\u0002\u07bf\u07b0\u0003\u0002\u0002',
-  '\u0002\u07bf\u07b3\u0003\u0002\u0002\u0002\u07bf\u07b5\u0003\u0002\u0002',
-  '\u0002\u07bf\u07b9\u0003\u0002\u0002\u0002\u07bf\u07bd\u0003\u0002\u0002',
-  '\u0002\u07c0\u07c2\u0003\u0002\u0002\u0002\u07c1\u07c3\u0007\u0099\u0002',
-  '\u0002\u07c2\u07c1\u0003\u0002\u0002\u0002\u07c2\u07c3\u0003\u0002\u0002',
-  '\u0002\u07c3\u07c4\u0003\u0002\u0002\u0002\u07c4\u07d0\u0005\u0118\u008d',
-  '\u0002\u07c5\u07c6\u0007\u0099\u0002\u0002\u07c6\u07c7\u0007F\u0002',
-  '\u0002\u07c7\u07c8\u0007\u0099\u0002\u0002\u07c8\u07d0\u0007t\u0002',
-  '\u0002\u07c9\u07ca\u0007\u0099\u0002\u0002\u07ca\u07cb\u0007F\u0002',
-  '\u0002\u07cb\u07cc\u0007\u0099\u0002\u0002\u07cc\u07cd\u0007p\u0002',
-  '\u0002\u07cd\u07ce\u0007\u0099\u0002\u0002\u07ce\u07d0\u0007t\u0002',
-  '\u0002\u07cf\u079d\u0003\u0002\u0002\u0002\u07cf\u07a4\u0003\u0002\u0002',
-  '\u0002\u07cf\u07bf\u0003\u0002\u0002\u0002\u07cf\u07c5\u0003\u0002\u0002',
-  '\u0002\u07cf\u07c9\u0003\u0002\u0002\u0002\u07d0\u07d3\u0003\u0002\u0002',
-  '\u0002\u07d1\u07cf\u0003\u0002\u0002\u0002\u07d1\u07d2\u0003\u0002\u0002',
-  '\u0002\u07d2\u0117\u0003\u0002\u0002\u0002\u07d3\u07d1\u0003\u0002\u0002',
-  '\u0002\u07d4\u07de\u0005\u0140\u00a1\u0002\u07d5\u07d7\u0007\u0099\u0002',
-  '\u0002\u07d6\u07d5\u0003\u0002\u0002\u0002\u07d6\u07d7\u0003\u0002\u0002',
-  '\u0002\u07d7\u07da\u0003\u0002\u0002\u0002\u07d8\u07db\u0005\u0160\u00b1',
-  '\u0002\u07d9\u07db\u0005\u00f8}\u0002\u07da\u07d8\u0003\u0002\u0002',
-  '\u0002\u07da\u07d9\u0003\u0002\u0002\u0002\u07db\u07dd\u0003\u0002\u0002',
-  '\u0002\u07dc\u07d6\u0003\u0002\u0002\u0002\u07dd\u07e0\u0003\u0002\u0002',
-  '\u0002\u07de\u07dc\u0003\u0002\u0002\u0002\u07de\u07df\u0003\u0002\u0002',
-  '\u0002\u07df\u0119\u0003\u0002\u0002\u0002\u07e0\u07de\u0003\u0002\u0002',
-  '\u0002\u07e1\u07e3\u0005\u011c\u008f\u0002\u07e2\u07e4\u0007\u0099\u0002',
-  '\u0002\u07e3\u07e2\u0003\u0002\u0002\u0002\u07e3\u07e4\u0003\u0002\u0002',
-  '\u0002\u07e4\u07e5\u0003\u0002\u0002\u0002\u07e5\u07e7\u0007\u0015\u0002',
-  '\u0002\u07e6\u07e8\u0007\u0099\u0002\u0002\u07e7\u07e6\u0003\u0002\u0002',
-  '\u0002\u07e7\u07e8\u0003\u0002\u0002\u0002\u07e8\u07e9\u0003\u0002\u0002',
-  '\u0002\u07e9\u07eb\u0005\u0150\u00a9\u0002\u07ea\u07ec\u0007\u0099\u0002',
-  '\u0002\u07eb\u07ea\u0003\u0002\u0002\u0002\u07eb\u07ec\u0003\u0002\u0002',
-  '\u0002\u07ec\u07ed\u0003\u0002\u0002\u0002\u07ed\u07ee\u0007\u0016\u0002',
-  '\u0002\u07ee\u011b\u0003\u0002\u0002\u0002\u07ef\u07f0\u0007v\u0002',
-  '\u0002\u07f0\u011d\u0003\u0002\u0002\u0002\u07f1\u07f3\u0005\u0120\u0091',
-  '\u0002\u07f2\u07f4\u0007\u0099\u0002\u0002\u07f3\u07f2\u0003\u0002\u0002',
-  '\u0002\u07f3\u07f4\u0003\u0002\u0002\u0002\u07f4\u07f5\u0003\u0002\u0002',
-  '\u0002\u07f5\u07f7\u0007\u0015\u0002\u0002\u07f6\u07f8\u0007\u0099\u0002',
-  '\u0002\u07f7\u07f6\u0003\u0002\u0002\u0002\u07f7\u07f8\u0003\u0002\u0002',
-  '\u0002\u07f8\u07f9\u0003\u0002\u0002\u0002\u07f9\u07fb\u0005\u0102\u0082',
-  '\u0002\u07fa\u07fc\u0007\u0099\u0002\u0002\u07fb\u07fa\u0003\u0002\u0002',
-  '\u0002\u07fb\u07fc\u0003\u0002\u0002\u0002\u07fc\u07fd\u0003\u0002\u0002',
-  '\u0002\u07fd\u07fe\u0007\u0016\u0002\u0002\u07fe\u011f\u0003\u0002\u0002',
-  '\u0002\u07ff\u0800\u0007H\u0002\u0002\u0800\u0121\u0003\u0002\u0002',
-  '\u0002\u0801\u0803\u0005\u0124\u0093\u0002\u0802\u0804\u0007\u0099\u0002',
-  '\u0002\u0803\u0802\u0003\u0002\u0002\u0002\u0803\u0804\u0003\u0002\u0002',
-  '\u0002\u0804\u0805\u0003\u0002\u0002\u0002\u0805\u0807\u0007\u0015\u0002',
-  '\u0002\u0806\u0808\u0007\u0099\u0002\u0002\u0807\u0806\u0003\u0002\u0002',
-  '\u0002\u0807\u0808\u0003\u0002\u0002\u0002\u0808\u0809\u0003\u0002\u0002',
-  '\u0002\u0809\u080b\u0005\u0150\u00a9\u0002\u080a\u080c\u0007\u0099\u0002',
-  '\u0002\u080b\u080a\u0003\u0002\u0002\u0002\u080b\u080c\u0003\u0002\u0002',
-  '\u0002\u080c\u080d\u0003\u0002\u0002\u0002\u080d\u080e\u0007\u0016\u0002',
-  '\u0002\u080e\u0123\u0003\u0002\u0002\u0002\u080f\u0810\u0007?\u0002',
-  '\u0002\u0810\u0125\u0003\u0002\u0002\u0002\u0811\u0813\u0005\u0128\u0095',
-  '\u0002\u0812\u0814\u0007\u0099\u0002\u0002\u0813\u0812\u0003\u0002\u0002',
-  '\u0002\u0813\u0814\u0003\u0002\u0002\u0002\u0814\u0815\u0003\u0002\u0002',
-  '\u0002\u0815\u0817\u0007\u0015\u0002\u0002\u0816\u0818\u0007\u0099\u0002',
-  '\u0002\u0817\u0816\u0003\u0002\u0002\u0002\u0817\u0818\u0003\u0002\u0002',
-  '\u0002\u0818\u0819\u0003\u0002\u0002\u0002\u0819\u081b\u0005\u0150\u00a9',
-  '\u0002\u081a\u081c\u0007\u0099\u0002\u0002\u081b\u081a\u0003\u0002\u0002',
-  '\u0002\u081b\u081c\u0003\u0002\u0002\u0002\u081c\u081d\u0003\u0002\u0002',
-  '\u0002\u081d\u081e\u0007\u0016\u0002\u0002\u081e\u0127\u0003\u0002\u0002',
-  '\u0002\u081f\u0820\u0007x\u0002\u0002\u0820\u0129\u0003\u0002\u0002',
-  '\u0002\u0821\u0823\u0005\u012c\u0097\u0002\u0822\u0824\u0007\u0099\u0002',
-  '\u0002\u0823\u0822\u0003\u0002\u0002\u0002\u0823\u0824\u0003\u0002\u0002',
-  '\u0002\u0824\u0825\u0003\u0002\u0002\u0002\u0825\u0827\u0007\u0015\u0002',
-  '\u0002\u0826\u0828\u0007\u0099\u0002\u0002\u0827\u0826\u0003\u0002\u0002',
-  '\u0002\u0827\u0828\u0003\u0002\u0002\u0002\u0828\u0829\u0003\u0002\u0002',
-  '\u0002\u0829\u082b\u0005\u0150\u00a9\u0002\u082a\u082c\u0007\u0099\u0002',
-  '\u0002\u082b\u082a\u0003\u0002\u0002\u0002\u082b\u082c\u0003\u0002\u0002',
-  '\u0002\u082c\u082d\u0003\u0002\u0002\u0002\u082d\u082e\u0007\u0016\u0002',
-  '\u0002\u082e\u012b\u0003\u0002\u0002\u0002\u082f\u0830\u0007y\u0002',
-  '\u0002\u0830\u012d\u0003\u0002\u0002\u0002\u0831\u0833\u0005\u0130\u0099',
-  '\u0002\u0832\u0834\u0007\u0099\u0002\u0002\u0833\u0832\u0003\u0002\u0002',
-  '\u0002\u0833\u0834\u0003\u0002\u0002\u0002\u0834\u0835\u0003\u0002\u0002',
-  '\u0002\u0835\u0837\u0007\u0015\u0002\u0002\u0836\u0838\u0007\u0099\u0002',
-  '\u0002\u0837\u0836\u0003\u0002\u0002\u0002\u0837\u0838\u0003\u0002\u0002',
-  '\u0002\u0838\u0839\u0003\u0002\u0002\u0002\u0839\u083b\u0005\u0150\u00a9',
-  '\u0002\u083a\u083c\u0007\u0099\u0002\u0002\u083b\u083a\u0003\u0002\u0002',
-  '\u0002\u083b\u083c\u0003\u0002\u0002\u0002\u083c\u083d\u0003\u0002\u0002',
-  '\u0002\u083d\u083e\u0007\u0016\u0002\u0002\u083e\u012f\u0003\u0002\u0002',
-  '\u0002\u083f\u0840\u0007z\u0002\u0002\u0840\u0131\u0003\u0002\u0002',
-  '\u0002\u0841\u0843\u0005\u0134\u009b\u0002\u0842\u0844\u0007\u0099\u0002',
-  '\u0002\u0843\u0842\u0003\u0002\u0002\u0002\u0843\u0844\u0003\u0002\u0002',
-  '\u0002\u0844\u0845\u0003\u0002\u0002\u0002\u0845\u0847\u0007\u0015\u0002',
-  '\u0002\u0846\u0848\u0007\u0099\u0002\u0002\u0847\u0846\u0003\u0002\u0002',
-  '\u0002\u0847\u0848\u0003\u0002\u0002\u0002\u0848\u0849\u0003\u0002\u0002',
-  '\u0002\u0849\u0852\u0005\u0150\u00a9\u0002\u084a\u084c\u0007\u0099\u0002',
-  '\u0002\u084b\u084a\u0003\u0002\u0002\u0002\u084b\u084c\u0003\u0002\u0002',
-  '\u0002\u084c\u084d\u0003\u0002\u0002\u0002\u084d\u084f\u0007\u0018\u0002',
-  '\u0002\u084e\u0850\u0007\u0099\u0002\u0002\u084f\u084e\u0003\u0002\u0002',
-  '\u0002\u084f\u0850\u0003\u0002\u0002\u0002\u0850\u0851\u0003\u0002\u0002',
-  '\u0002\u0851\u0853\u0005\u0102\u0082\u0002\u0852\u084b\u0003\u0002\u0002',
-  '\u0002\u0852\u0853\u0003\u0002\u0002\u0002\u0853\u0855\u0003\u0002\u0002',
-  '\u0002\u0854\u0856\u0007\u0099\u0002\u0002\u0855\u0854\u0003\u0002\u0002',
-  '\u0002\u0855\u0856\u0003\u0002\u0002\u0002\u0856\u0857\u0003\u0002\u0002',
-  '\u0002\u0857\u0858\u0007\u0016\u0002\u0002\u0858\u0133\u0003\u0002\u0002',
-  '\u0002\u0859\u085a\u0007w\u0002\u0002\u085a\u0135\u0003\u0002\u0002',
-  '\u0002\u085b\u085d\u0005\u0138\u009d\u0002\u085c\u085e\u0007\u0099\u0002',
-  '\u0002\u085d\u085c\u0003\u0002\u0002\u0002\u085d\u085e\u0003\u0002\u0002',
-  '\u0002\u085e\u085f\u0003\u0002\u0002\u0002\u085f\u0861\u0007\u0015\u0002',
-  '\u0002\u0860\u0862\u0007\u0099\u0002\u0002\u0861\u0860\u0003\u0002\u0002',
-  '\u0002\u0861\u0862\u0003\u0002\u0002\u0002\u0862\u0863\u0003\u0002\u0002',
-  '\u0002\u0863\u0865\u0005\u0166\u00b4\u0002\u0864\u0866\u0007\u0099\u0002',
-  '\u0002\u0865\u0864\u0003\u0002\u0002\u0002\u0865\u0866\u0003\u0002\u0002',
-  '\u0002\u0866\u0867\u0003\u0002\u0002\u0002\u0867\u0869\u0007\u000e\u0002',
-  '\u0002\u0868\u086a\u0007\u0099\u0002\u0002\u0869\u0868\u0003\u0002\u0002',
-  '\u0002\u0869\u086a\u0003\u0002\u0002\u0002\u086a\u086b\u0003\u0002\u0002',
-  '\u0002\u086b\u086d\u0005\u0102\u0082\u0002\u086c\u086e\u0007\u0099\u0002',
-  '\u0002\u086d\u086c\u0003\u0002\u0002\u0002\u086d\u086e\u0003\u0002\u0002',
-  '\u0002\u086e\u086f\u0003\u0002\u0002\u0002\u086f\u0871\u0007\u0011\u0002',
-  '\u0002\u0870\u0872\u0007\u0099\u0002\u0002\u0871\u0870\u0003\u0002\u0002',
-  '\u0002\u0871\u0872\u0003\u0002\u0002\u0002\u0872\u0873\u0003\u0002\u0002',
-  '\u0002\u0873\u0875\u0005\u0152\u00aa\u0002\u0874\u0876\u0007\u0099\u0002',
-  '\u0002\u0875\u0874\u0003\u0002\u0002\u0002\u0875\u0876\u0003\u0002\u0002',
-  '\u0002\u0876\u0877\u0003\u0002\u0002\u0002\u0877\u0879\u0007\u0018\u0002',
-  '\u0002\u0878\u087a\u0007\u0099\u0002\u0002\u0879\u0878\u0003\u0002\u0002',
-  '\u0002\u0879\u087a\u0003\u0002\u0002\u0002\u087a\u087b\u0003\u0002\u0002',
-  '\u0002\u087b\u087d\u0005\u0102\u0082\u0002\u087c\u087e\u0007\u0099\u0002',
-  '\u0002\u087d\u087c\u0003\u0002\u0002\u0002\u087d\u087e\u0003\u0002\u0002',
-  '\u0002\u087e\u087f\u0003\u0002\u0002\u0002\u087f\u0880\u0007\u0016\u0002',
-  '\u0002\u0880\u0137\u0003\u0002\u0002\u0002\u0881\u0882\u0007}\u0002',
-  '\u0002\u0882\u0139\u0003\u0002\u0002\u0002\u0883\u0885\u0005\u013c\u009f',
-  '\u0002\u0884\u0886\u0007\u0099\u0002\u0002\u0885\u0884\u0003\u0002\u0002',
-  '\u0002\u0885\u0886\u0003\u0002\u0002\u0002\u0886\u0887\u0003\u0002\u0002',
-  '\u0002\u0887\u0889\u0007\u0015\u0002\u0002\u0888\u088a\u0007\u0099\u0002',
-  '\u0002\u0889\u0888\u0003\u0002\u0002\u0002\u0889\u088a\u0003\u0002\u0002',
-  '\u0002\u088a\u088b\u0003\u0002\u0002\u0002\u088b\u088d\u0005\u00e0q',
-  '\u0002\u088c\u088e\u0007\u0099\u0002\u0002\u088d\u088c\u0003\u0002\u0002',
-  '\u0002\u088d\u088e\u0003\u0002\u0002\u0002\u088e\u088f\u0003\u0002\u0002',
-  '\u0002\u088f\u0890\u0007\u0016\u0002\u0002\u0890\u08a0\u0003\u0002\u0002',
-  '\u0002\u0891\u0893\u0005\u013e\u00a0\u0002\u0892\u0894\u0007\u0099\u0002',
-  '\u0002\u0893\u0892\u0003\u0002\u0002\u0002\u0893\u0894\u0003\u0002\u0002',
-  '\u0002\u0894\u0895\u0003\u0002\u0002\u0002\u0895\u0897\u0007\u0015\u0002',
-  '\u0002\u0896\u0898\u0007\u0099\u0002\u0002\u0897\u0896\u0003\u0002\u0002',
-  '\u0002\u0897\u0898\u0003\u0002\u0002\u0002\u0898\u0899\u0003\u0002\u0002',
-  '\u0002\u0899\u089b\u0005\u00e0q\u0002\u089a\u089c\u0007\u0099\u0002',
-  '\u0002\u089b\u089a\u0003\u0002\u0002\u0002\u089b\u089c\u0003\u0002\u0002',
-  '\u0002\u089c\u089d\u0003\u0002\u0002\u0002\u089d\u089e\u0007\u0016\u0002',
-  '\u0002\u089e\u08a0\u0003\u0002\u0002\u0002\u089f\u0883\u0003\u0002\u0002',
-  '\u0002\u089f\u0891\u0003\u0002\u0002\u0002\u08a0\u013b\u0003\u0002\u0002',
-  '\u0002\u08a1\u08a2\u0007k\u0002\u0002\u08a2\u013d\u0003\u0002\u0002',
-  '\u0002\u08a3\u08a4\u0007l\u0002\u0002\u08a4\u013f\u0003\u0002\u0002',
-  '\u0002\u08a5\u08c5\u0005\u0142\u00a2\u0002\u08a6\u08c5\u0005\u0178\u00bd',
-  '\u0002\u08a7\u08c5\u0005\u0162\u00b2\u0002\u08a8\u08aa\u0007u\u0002',
-  '\u0002\u08a9\u08ab\u0007\u0099\u0002\u0002\u08aa\u08a9\u0003\u0002\u0002',
-  '\u0002\u08aa\u08ab\u0003\u0002\u0002\u0002\u08ab\u08ac\u0003\u0002\u0002',
-  '\u0002\u08ac\u08ae\u0007\u0015\u0002\u0002\u08ad\u08af\u0007\u0099\u0002',
-  '\u0002\u08ae\u08ad\u0003\u0002\u0002\u0002\u08ae\u08af\u0003\u0002\u0002',
-  '\u0002\u08af\u08b0\u0003\u0002\u0002\u0002\u08b0\u08b2\u0007\u0019\u0002',
-  '\u0002\u08b1\u08b3\u0007\u0099\u0002\u0002\u08b2\u08b1\u0003\u0002\u0002',
-  '\u0002\u08b2\u08b3\u0003\u0002\u0002\u0002\u08b3\u08b4\u0003\u0002\u0002',
-  '\u0002\u08b4\u08c5\u0007\u0016\u0002\u0002\u08b5\u08c5\u0005\u015c\u00af',
-  '\u0002\u08b6\u08c5\u0005\u015e\u00b0\u0002\u08b7\u08c5\u0005\u011a\u008e',
-  '\u0002\u08b8\u08c5\u0005\u0132\u009a\u0002\u08b9\u08c5\u0005\u0136\u009c',
-  '\u0002\u08ba\u08c5\u0005\u0122\u0092\u0002\u08bb\u08c5\u0005\u0126\u0094',
-  '\u0002\u08bc\u08c5\u0005\u012a\u0096\u0002\u08bd\u08c5\u0005\u012e\u0098',
-  '\u0002\u08be\u08c5\u0005\u011e\u0090\u0002\u08bf\u08c5\u0005\u013a\u009e',
-  '\u0002\u08c0\u08c5\u0005\u014e\u00a8\u0002\u08c1\u08c5\u0005\u014c\u00a7',
-  '\u0002\u08c2\u08c5\u0005\u0154\u00ab\u0002\u08c3\u08c5\u0005\u0166\u00b4',
-  '\u0002\u08c4\u08a5\u0003\u0002\u0002\u0002\u08c4\u08a6\u0003\u0002\u0002',
-  '\u0002\u08c4\u08a7\u0003\u0002\u0002\u0002\u08c4\u08a8\u0003\u0002\u0002',
-  '\u0002\u08c4\u08b5\u0003\u0002\u0002\u0002\u08c4\u08b6\u0003\u0002\u0002',
-  '\u0002\u08c4\u08b7\u0003\u0002\u0002\u0002\u08c4\u08b8\u0003\u0002\u0002',
-  '\u0002\u08c4\u08b9\u0003\u0002\u0002\u0002\u08c4\u08ba\u0003\u0002\u0002',
-  '\u0002\u08c4\u08bb\u0003\u0002\u0002\u0002\u08c4\u08bc\u0003\u0002\u0002',
-  '\u0002\u08c4\u08bd\u0003\u0002\u0002\u0002\u08c4\u08be\u0003\u0002\u0002',
-  '\u0002\u08c4\u08bf\u0003\u0002\u0002\u0002\u08c4\u08c0\u0003\u0002\u0002',
-  '\u0002\u08c4\u08c1\u0003\u0002\u0002\u0002\u08c4\u08c2\u0003\u0002\u0002',
-  '\u0002\u08c4\u08c3\u0003\u0002\u0002\u0002\u08c5\u0141\u0003\u0002\u0002',
-  '\u0002\u08c6\u08ce\u0005\u0168\u00b5\u0002\u08c7\u08ce\u0005\u0144\u00a3',
-  '\u0002\u08c8\u08ce\u0005\u0146\u00a4\u0002\u08c9\u08ce\u0007t\u0002',
-  '\u0002\u08ca\u08ce\u0005\u016a\u00b6\u0002\u08cb\u08ce\u0005\u0148\u00a5',
-  '\u0002\u08cc\u08ce\u0005\u016c\u00b7\u0002\u08cd\u08c6\u0003\u0002\u0002',
-  '\u0002\u08cd\u08c7\u0003\u0002\u0002\u0002\u08cd\u08c8\u0003\u0002\u0002',
-  '\u0002\u08cd\u08c9\u0003\u0002\u0002\u0002\u08cd\u08ca\u0003\u0002\u0002',
-  '\u0002\u08cd\u08cb\u0003\u0002\u0002\u0002\u08cd\u08cc\u0003\u0002\u0002',
-  '\u0002\u08ce\u0143\u0003\u0002\u0002\u0002\u08cf\u08d0\u0007\u0086\u0002',
-  '\u0002\u08d0\u0145\u0003\u0002\u0002\u0002\u08d1\u08d2\t\u0006\u0002',
-  '\u0002\u08d2\u0147\u0003\u0002\u0002\u0002\u08d3\u08d5\u0007\u0013\u0002',
-  '\u0002\u08d4\u08d6\u0007\u0099\u0002\u0002\u08d5\u08d4\u0003\u0002\u0002',
-  '\u0002\u08d5\u08d6\u0003\u0002\u0002\u0002\u08d6\u08e8\u0003\u0002\u0002',
-  '\u0002\u08d7\u08d9\u0005\u0102\u0082\u0002\u08d8\u08da\u0007\u0099\u0002',
-  '\u0002\u08d9\u08d8\u0003\u0002\u0002\u0002\u08d9\u08da\u0003\u0002\u0002',
-  '\u0002\u08da\u08e5\u0003\u0002\u0002\u0002\u08db\u08dd\u0007\u0011\u0002',
-  '\u0002\u08dc\u08de\u0007\u0099\u0002\u0002\u08dd\u08dc\u0003\u0002\u0002',
-  '\u0002\u08dd\u08de\u0003\u0002\u0002\u0002\u08de\u08df\u0003\u0002\u0002',
-  '\u0002\u08df\u08e1\u0005\u0102\u0082\u0002\u08e0\u08e2\u0007\u0099\u0002',
-  '\u0002\u08e1\u08e0\u0003\u0002\u0002\u0002\u08e1\u08e2\u0003\u0002\u0002',
-  '\u0002\u08e2\u08e4\u0003\u0002\u0002\u0002\u08e3\u08db\u0003\u0002\u0002',
-  '\u0002\u08e4\u08e7\u0003\u0002\u0002\u0002\u08e5\u08e3\u0003\u0002\u0002',
-  '\u0002\u08e5\u08e6\u0003\u0002\u0002\u0002\u08e6\u08e9\u0003\u0002\u0002',
-  '\u0002\u08e7\u08e5\u0003\u0002\u0002\u0002\u08e8\u08d7\u0003\u0002\u0002',
-  '\u0002\u08e8\u08e9\u0003\u0002\u0002\u0002\u08e9\u08ea\u0003\u0002\u0002',
-  '\u0002\u08ea\u08eb\u0007\u0014\u0002\u0002\u08eb\u0149\u0003\u0002\u0002',
-  '\u0002\u08ec\u08ee\u0007\u000e\u0002\u0002\u08ed\u08ef\u0007\u0099\u0002',
-  '\u0002\u08ee\u08ed\u0003\u0002\u0002\u0002\u08ee\u08ef\u0003\u0002\u0002',
-  '\u0002\u08ef\u08f0\u0003\u0002\u0002\u0002\u08f0\u0910\u0005\u010e\u0088',
-  '\u0002\u08f1\u08f3\u0007\u001e\u0002\u0002\u08f2\u08f4\u0007\u0099\u0002',
-  '\u0002\u08f3\u08f2\u0003\u0002\u0002\u0002\u08f3\u08f4\u0003\u0002\u0002',
-  '\u0002\u08f4\u08f5\u0003\u0002\u0002\u0002\u08f5\u0910\u0005\u010e\u0088',
-  '\u0002\u08f6\u08f8\u0007\u001f\u0002\u0002\u08f7\u08f9\u0007\u0099\u0002',
-  '\u0002\u08f8\u08f7\u0003\u0002\u0002\u0002\u08f8\u08f9\u0003\u0002\u0002',
-  '\u0002\u08f9\u08fa\u0003\u0002\u0002\u0002\u08fa\u0910\u0005\u010e\u0088',
-  '\u0002\u08fb\u08fd\u0007 \u0002\u0002\u08fc\u08fe\u0007\u0099\u0002',
-  '\u0002\u08fd\u08fc\u0003\u0002\u0002\u0002\u08fd\u08fe\u0003\u0002\u0002',
-  '\u0002\u08fe\u08ff\u0003\u0002\u0002\u0002\u08ff\u0910\u0005\u010e\u0088',
-  '\u0002\u0900\u0902\u0007!\u0002\u0002\u0901\u0903\u0007\u0099\u0002',
-  '\u0002\u0902\u0901\u0003\u0002\u0002\u0002\u0902\u0903\u0003\u0002\u0002',
-  '\u0002\u0903\u0904\u0003\u0002\u0002\u0002\u0904\u0910\u0005\u010e\u0088',
-  '\u0002\u0905\u0907\u0007"\u0002\u0002\u0906\u0908\u0007\u0099\u0002',
-  '\u0002\u0907\u0906\u0003\u0002\u0002\u0002\u0907\u0908\u0003\u0002\u0002',
-  '\u0002\u0908\u0909\u0003\u0002\u0002\u0002\u0909\u0910\u0005\u010e\u0088',
-  '\u0002\u090a\u090c\u0007#\u0002\u0002\u090b\u090d\u0007\u0099\u0002',
-  '\u0002\u090c\u090b\u0003\u0002\u0002\u0002\u090c\u090d\u0003\u0002\u0002',
-  '\u0002\u090d\u090e\u0003\u0002\u0002\u0002\u090e\u0910\u0005\u010e\u0088',
-  '\u0002\u090f\u08ec\u0003\u0002\u0002\u0002\u090f\u08f1\u0003\u0002\u0002',
-  '\u0002\u090f\u08f6\u0003\u0002\u0002\u0002\u090f\u08fb\u0003\u0002\u0002',
-  '\u0002\u090f\u0900\u0003\u0002\u0002\u0002\u090f\u0905\u0003\u0002\u0002',
-  '\u0002\u090f\u090a\u0003\u0002\u0002\u0002\u0910\u014b\u0003\u0002\u0002',
-  '\u0002\u0911\u0913\u0007\u0015\u0002\u0002\u0912\u0914\u0007\u0099\u0002',
-  '\u0002\u0913\u0912\u0003\u0002\u0002\u0002\u0913\u0914\u0003\u0002\u0002',
-  '\u0002\u0914\u0915\u0003\u0002\u0002\u0002\u0915\u0917\u0005\u0102\u0082',
-  '\u0002\u0916\u0918\u0007\u0099\u0002\u0002\u0917\u0916\u0003\u0002\u0002',
-  '\u0002\u0917\u0918\u0003\u0002\u0002\u0002\u0918\u0919\u0003\u0002\u0002',
-  '\u0002\u0919\u091a\u0007\u0016\u0002\u0002\u091a\u014d\u0003\u0002\u0002',
-  '\u0002\u091b\u0920\u0005\u00e2r\u0002\u091c\u091e\u0007\u0099\u0002',
-  '\u0002\u091d\u091c\u0003\u0002\u0002\u0002\u091d\u091e\u0003\u0002\u0002',
-  '\u0002\u091e\u091f\u0003\u0002\u0002\u0002\u091f\u0921\u0005\u00e4s',
-  '\u0002\u0920\u091d\u0003\u0002\u0002\u0002\u0921\u0922\u0003\u0002\u0002',
-  '\u0002\u0922\u0920\u0003\u0002\u0002\u0002\u0922\u0923\u0003\u0002\u0002',
-  '\u0002\u0923\u014f\u0003\u0002\u0002\u0002\u0924\u0929\u0005\u0152\u00aa',
-  '\u0002\u0925\u0927\u0007\u0099\u0002\u0002\u0926\u0925\u0003\u0002\u0002',
-  '\u0002\u0926\u0927\u0003\u0002\u0002\u0002\u0927\u0928\u0003\u0002\u0002',
-  '\u0002\u0928\u092a\u0005\u00d8m\u0002\u0929\u0926\u0003\u0002\u0002',
-  '\u0002\u0929\u092a\u0003\u0002\u0002\u0002\u092a\u0151\u0003\u0002\u0002',
-  '\u0002\u092b\u092c\u0005\u0166\u00b4\u0002\u092c\u092d\u0007\u0099\u0002',
-  '\u0002\u092d\u092e\u0007Y\u0002\u0002\u092e\u092f\u0007\u0099\u0002',
-  '\u0002\u092f\u0930\u0005\u0102\u0082\u0002\u0930\u0153\u0003\u0002\u0002',
-  '\u0002\u0931\u0933\u0005\u0156\u00ac\u0002\u0932\u0934\u0007\u0099\u0002',
-  '\u0002\u0933\u0932\u0003\u0002\u0002\u0002\u0933\u0934\u0003\u0002\u0002',
-  '\u0002\u0934\u0935\u0003\u0002\u0002\u0002\u0935\u0937\u0007\u0015\u0002',
-  '\u0002\u0936\u0938\u0007\u0099\u0002\u0002\u0937\u0936\u0003\u0002\u0002',
-  '\u0002\u0937\u0938\u0003\u0002\u0002\u0002\u0938\u093d\u0003\u0002\u0002',
-  '\u0002\u0939\u093b\u0007Z\u0002\u0002\u093a\u093c\u0007\u0099\u0002',
-  '\u0002\u093b\u093a\u0003\u0002\u0002\u0002\u093b\u093c\u0003\u0002\u0002',
-  '\u0002\u093c\u093e\u0003\u0002\u0002\u0002\u093d\u0939\u0003\u0002\u0002',
-  '\u0002\u093d\u093e\u0003\u0002\u0002\u0002\u093e\u0950\u0003\u0002\u0002',
-  '\u0002\u093f\u0941\u0005\u0102\u0082\u0002\u0940\u0942\u0007\u0099\u0002',
-  '\u0002\u0941\u0940\u0003\u0002\u0002\u0002\u0941\u0942\u0003\u0002\u0002',
-  '\u0002\u0942\u094d\u0003\u0002\u0002\u0002\u0943\u0945\u0007\u0011\u0002',
-  '\u0002\u0944\u0946\u0007\u0099\u0002\u0002\u0945\u0944\u0003\u0002\u0002',
-  '\u0002\u0945\u0946\u0003\u0002\u0002\u0002\u0946\u0947\u0003\u0002\u0002',
-  '\u0002\u0947\u0949\u0005\u0102\u0082\u0002\u0948\u094a\u0007\u0099\u0002',
-  '\u0002\u0949\u0948\u0003\u0002\u0002\u0002\u0949\u094a\u0003\u0002\u0002',
-  '\u0002\u094a\u094c\u0003\u0002\u0002\u0002\u094b\u0943\u0003\u0002\u0002',
-  '\u0002\u094c\u094f\u0003\u0002\u0002\u0002\u094d\u094b\u0003\u0002\u0002',
-  '\u0002\u094d\u094e\u0003\u0002\u0002\u0002\u094e\u0951\u0003\u0002\u0002',
-  '\u0002\u094f\u094d\u0003\u0002\u0002\u0002\u0950\u093f\u0003\u0002\u0002',
-  '\u0002\u0950\u0951\u0003\u0002\u0002\u0002\u0951\u0952\u0003\u0002\u0002',
-  '\u0002\u0952\u0953\u0007\u0016\u0002\u0002\u0953\u0155\u0003\u0002\u0002',
-  '\u0002\u0954\u0955\u0005\u018c\u00c7\u0002\u0955\u0956\u0005\u0158\u00ad',
-  '\u0002\u0956\u0157\u0003\u0002\u0002\u0002\u0957\u0958\t\u0007\u0002',
-  '\u0002\u0958\u0159\u0003\u0002\u0002\u0002\u0959\u095a\u0005\u0194\u00cb',
-  '\u0002\u095a\u015b\u0003\u0002\u0002\u0002\u095b\u095d\u0007\u0013\u0002',
-  '\u0002\u095c\u095e\u0007\u0099\u0002\u0002\u095d\u095c\u0003\u0002\u0002',
-  '\u0002\u095d\u095e\u0003\u0002\u0002\u0002\u095e\u095f\u0003\u0002\u0002',
-  '\u0002\u095f\u0968\u0005\u0150\u00a9\u0002\u0960\u0962\u0007\u0099\u0002',
-  '\u0002\u0961\u0960\u0003\u0002\u0002\u0002\u0961\u0962\u0003\u0002\u0002',
-  '\u0002\u0962\u0963\u0003\u0002\u0002\u0002\u0963\u0965\u0007\u0018\u0002',
-  '\u0002\u0964\u0966\u0007\u0099\u0002\u0002\u0965\u0964\u0003\u0002\u0002',
-  '\u0002\u0965\u0966\u0003\u0002\u0002\u0002\u0966\u0967\u0003\u0002\u0002',
-  '\u0002\u0967\u0969\u0005\u0102\u0082\u0002\u0968\u0961\u0003\u0002\u0002',
-  '\u0002\u0968\u0969\u0003\u0002\u0002\u0002\u0969\u096b\u0003\u0002\u0002',
-  '\u0002\u096a\u096c\u0007\u0099\u0002\u0002\u096b\u096a\u0003\u0002\u0002',
-  '\u0002\u096b\u096c\u0003\u0002\u0002\u0002\u096c\u096d\u0003\u0002\u0002',
-  '\u0002\u096d\u096e\u0007\u0014\u0002\u0002\u096e\u015d\u0003\u0002\u0002',
-  '\u0002\u096f\u0971\u0007\u0013\u0002\u0002\u0970\u0972\u0007\u0099\u0002',
-  '\u0002\u0971\u0970\u0003\u0002\u0002\u0002\u0971\u0972\u0003\u0002\u0002',
-  '\u0002\u0972\u097b\u0003\u0002\u0002\u0002\u0973\u0975\u0005\u0166\u00b4',
-  '\u0002\u0974\u0976\u0007\u0099\u0002\u0002\u0975\u0974\u0003\u0002\u0002',
-  '\u0002\u0975\u0976\u0003\u0002\u0002\u0002\u0976\u0977\u0003\u0002\u0002',
-  '\u0002\u0977\u0979\u0007\u000e\u0002\u0002\u0978\u097a\u0007\u0099\u0002',
-  '\u0002\u0979\u0978\u0003\u0002\u0002\u0002\u0979\u097a\u0003\u0002\u0002',
-  '\u0002\u097a\u097c\u0003\u0002\u0002\u0002\u097b\u0973\u0003\u0002\u0002',
-  '\u0002\u097b\u097c\u0003\u0002\u0002\u0002\u097c\u097d\u0003\u0002\u0002',
-  '\u0002\u097d\u097f\u0005\u014e\u00a8\u0002\u097e\u0980\u0007\u0099\u0002',
-  '\u0002\u097f\u097e\u0003\u0002\u0002\u0002\u097f\u0980\u0003\u0002\u0002',
-  '\u0002\u0980\u0989\u0003\u0002\u0002\u0002\u0981\u0983\u0007j\u0002',
-  '\u0002\u0982\u0984\u0007\u0099\u0002\u0002\u0983\u0982\u0003\u0002\u0002',
-  '\u0002\u0983\u0984\u0003\u0002\u0002\u0002\u0984\u0985\u0003\u0002\u0002',
-  '\u0002\u0985\u0987\u0005\u0102\u0082\u0002\u0986\u0988\u0007\u0099\u0002',
-  '\u0002\u0987\u0986\u0003\u0002\u0002\u0002\u0987\u0988\u0003\u0002\u0002',
-  '\u0002\u0988\u098a\u0003\u0002\u0002\u0002\u0989\u0981\u0003\u0002\u0002',
-  '\u0002\u0989\u098a\u0003\u0002\u0002\u0002\u098a\u098b\u0003\u0002\u0002',
-  '\u0002\u098b\u098d\u0007\u0018\u0002\u0002\u098c\u098e\u0007\u0099\u0002',
-  '\u0002\u098d\u098c\u0003\u0002\u0002\u0002\u098d\u098e\u0003\u0002\u0002',
-  '\u0002\u098e\u098f\u0003\u0002\u0002\u0002\u098f\u0991\u0005\u0102\u0082',
-  '\u0002\u0990\u0992\u0007\u0099\u0002\u0002\u0991\u0990\u0003\u0002\u0002',
-  '\u0002\u0991\u0992\u0003\u0002\u0002\u0002\u0992\u0993\u0003\u0002\u0002',
-  '\u0002\u0993\u0994\u0007\u0014\u0002\u0002\u0994\u015f\u0003\u0002\u0002',
-  '\u0002\u0995\u0997\u0007\t\u0002\u0002\u0996\u0998\u0007\u0099\u0002',
-  '\u0002\u0997\u0996\u0003\u0002\u0002\u0002\u0997\u0998\u0003\u0002\u0002',
-  '\u0002\u0998\u0999\u0003\u0002\u0002\u0002\u0999\u099a\u0005\u0186\u00c4',
-  '\u0002\u099a\u0161\u0003\u0002\u0002\u0002\u099b\u09a0\u0007~\u0002',
-  '\u0002\u099c\u099e\u0007\u0099\u0002\u0002\u099d\u099c\u0003\u0002\u0002',
-  '\u0002\u099d\u099e\u0003\u0002\u0002\u0002\u099e\u099f\u0003\u0002\u0002',
-  '\u0002\u099f\u09a1\u0005\u0164\u00b3\u0002\u09a0\u099d\u0003\u0002\u0002',
-  '\u0002\u09a1\u09a2\u0003\u0002\u0002\u0002\u09a2\u09a0\u0003\u0002\u0002',
-  '\u0002\u09a2\u09a3\u0003\u0002\u0002\u0002\u09a3\u09b2\u0003\u0002\u0002',
-  '\u0002\u09a4\u09a6\u0007~\u0002\u0002\u09a5\u09a7\u0007\u0099\u0002',
-  '\u0002\u09a6\u09a5\u0003\u0002\u0002\u0002\u09a6\u09a7\u0003\u0002\u0002',
-  '\u0002\u09a7\u09a8\u0003\u0002\u0002\u0002\u09a8\u09ad\u0005\u0102\u0082',
-  '\u0002\u09a9\u09ab\u0007\u0099\u0002\u0002\u09aa\u09a9\u0003\u0002\u0002',
-  '\u0002\u09aa\u09ab\u0003\u0002\u0002\u0002\u09ab\u09ac\u0003\u0002\u0002',
-  '\u0002\u09ac\u09ae\u0005\u0164\u00b3\u0002\u09ad\u09aa\u0003\u0002\u0002',
-  '\u0002\u09ae\u09af\u0003\u0002\u0002\u0002\u09af\u09ad\u0003\u0002\u0002',
-  '\u0002\u09af\u09b0\u0003\u0002\u0002\u0002\u09b0\u09b2\u0003\u0002\u0002',
-  '\u0002\u09b1\u099b\u0003\u0002\u0002\u0002\u09b1\u09a4\u0003\u0002\u0002',
-  '\u0002\u09b2\u09bb\u0003\u0002\u0002\u0002\u09b3\u09b5\u0007\u0099\u0002',
-  '\u0002\u09b4\u09b3\u0003\u0002\u0002\u0002\u09b4\u09b5\u0003\u0002\u0002',
-  '\u0002\u09b5\u09b6\u0003\u0002\u0002\u0002\u09b6\u09b8\u0007\u007f\u0002',
-  '\u0002\u09b7\u09b9\u0007\u0099\u0002\u0002\u09b8\u09b7\u0003\u0002\u0002',
-  '\u0002\u09b8\u09b9\u0003\u0002\u0002\u0002\u09b9\u09ba\u0003\u0002\u0002',
-  '\u0002\u09ba\u09bc\u0005\u0102\u0082\u0002\u09bb\u09b4\u0003\u0002\u0002',
-  '\u0002\u09bb\u09bc\u0003\u0002\u0002\u0002\u09bc\u09be\u0003\u0002\u0002',
-  '\u0002\u09bd\u09bf\u0007\u0099\u0002\u0002\u09be\u09bd\u0003\u0002\u0002',
-  '\u0002\u09be\u09bf\u0003\u0002\u0002\u0002\u09bf\u09c0\u0003\u0002\u0002',
-  '\u0002\u09c0\u09c1\u0007\u0080\u0002\u0002\u09c1\u0163\u0003\u0002\u0002',
-  '\u0002\u09c2\u09c4\u0007\u0081\u0002\u0002\u09c3\u09c5\u0007\u0099\u0002',
-  '\u0002\u09c4\u09c3\u0003\u0002\u0002\u0002\u09c4\u09c5\u0003\u0002\u0002',
-  '\u0002\u09c5\u09c6\u0003\u0002\u0002\u0002\u09c6\u09c8\u0005\u0102\u0082',
-  '\u0002\u09c7\u09c9\u0007\u0099\u0002\u0002\u09c8\u09c7\u0003\u0002\u0002',
-  '\u0002\u09c8\u09c9\u0003\u0002\u0002\u0002\u09c9\u09ca\u0003\u0002\u0002',
-  '\u0002\u09ca\u09cc\u0007\u0082\u0002\u0002\u09cb\u09cd\u0007\u0099\u0002',
-  '\u0002\u09cc\u09cb\u0003\u0002\u0002\u0002\u09cc\u09cd\u0003\u0002\u0002',
-  '\u0002\u09cd\u09ce\u0003\u0002\u0002\u0002\u09ce\u09cf\u0005\u0102\u0082',
-  '\u0002\u09cf\u0165\u0003\u0002\u0002\u0002\u09d0\u09d1\u0005\u0194\u00cb',
-  '\u0002\u09d1\u0167\u0003\u0002\u0002\u0002\u09d2\u09d5\u0005\u018a\u00c6',
-  '\u0002\u09d3\u09d5\u0005\u0188\u00c5\u0002\u09d4\u09d2\u0003\u0002\u0002',
-  '\u0002\u09d4\u09d3\u0003\u0002\u0002\u0002\u09d5\u0169\u0003\u0002\u0002',
-  '\u0002\u09d6\u09d8\u0007\u0010\u0002\u0002\u09d7\u09d9\u0007\u0099\u0002',
-  '\u0002\u09d8\u09d7\u0003\u0002\u0002\u0002\u09d8\u09d9\u0003\u0002\u0002',
-  '\u0002\u09d9\u09eb\u0003\u0002\u0002\u0002\u09da\u09dc\u0005\u0170\u00b9',
-  '\u0002\u09db\u09dd\u0007\u0099\u0002\u0002\u09dc\u09db\u0003\u0002\u0002',
-  '\u0002\u09dc\u09dd\u0003\u0002\u0002\u0002\u09dd\u09e8\u0003\u0002\u0002',
-  '\u0002\u09de\u09e0\u0007\u0011\u0002\u0002\u09df\u09e1\u0007\u0099\u0002',
-  '\u0002\u09e0\u09df\u0003\u0002\u0002\u0002\u09e0\u09e1\u0003\u0002\u0002',
-  '\u0002\u09e1\u09e2\u0003\u0002\u0002\u0002\u09e2\u09e4\u0005\u0170\u00b9',
-  '\u0002\u09e3\u09e5\u0007\u0099\u0002\u0002\u09e4\u09e3\u0003\u0002\u0002',
-  '\u0002\u09e4\u09e5\u0003\u0002\u0002\u0002\u09e5\u09e7\u0003\u0002\u0002',
-  '\u0002\u09e6\u09de\u0003\u0002\u0002\u0002\u09e7\u09ea\u0003\u0002\u0002',
-  '\u0002\u09e8\u09e6\u0003\u0002\u0002\u0002\u09e8\u09e9\u0003\u0002\u0002',
-  '\u0002\u09e9\u09ec\u0003\u0002\u0002\u0002\u09ea\u09e8\u0003\u0002\u0002',
-  '\u0002\u09eb\u09da\u0003\u0002\u0002\u0002\u09eb\u09ec\u0003\u0002\u0002',
-  '\u0002\u09ec\u09ed\u0003\u0002\u0002\u0002\u09ed\u09ee\u0007\u0012\u0002',
-  '\u0002\u09ee\u016b\u0003\u0002\u0002\u0002\u09ef\u09f1\u0005\u0166\u00b4',
-  '\u0002\u09f0\u09f2\u0007\u0099\u0002\u0002\u09f1\u09f0\u0003\u0002\u0002',
-  '\u0002\u09f1\u09f2\u0003\u0002\u0002\u0002\u09f2\u09f3\u0003\u0002\u0002',
-  '\u0002\u09f3\u09f5\u0007\u0010\u0002\u0002\u09f4\u09f6\u0007\u0099\u0002',
-  '\u0002\u09f5\u09f4\u0003\u0002\u0002\u0002\u09f5\u09f6\u0003\u0002\u0002',
-  '\u0002\u09f6\u09f8\u0003\u0002\u0002\u0002\u09f7\u09f9\u0005\u016e\u00b8',
-  '\u0002\u09f8\u09f7\u0003\u0002\u0002\u0002\u09f8\u09f9\u0003\u0002\u0002',
-  '\u0002\u09f9\u0a04\u0003\u0002\u0002\u0002\u09fa\u09fc\u0007\u0099\u0002',
-  '\u0002\u09fb\u09fa\u0003\u0002\u0002\u0002\u09fb\u09fc\u0003\u0002\u0002',
-  '\u0002\u09fc\u09fd\u0003\u0002\u0002\u0002\u09fd\u09ff\u0007\u0011\u0002',
-  '\u0002\u09fe\u0a00\u0007\u0099\u0002\u0002\u09ff\u09fe\u0003\u0002\u0002',
-  '\u0002\u09ff\u0a00\u0003\u0002\u0002\u0002\u0a00\u0a01\u0003\u0002\u0002',
-  '\u0002\u0a01\u0a03\u0005\u016e\u00b8\u0002\u0a02\u09fb\u0003\u0002\u0002',
-  '\u0002\u0a03\u0a06\u0003\u0002\u0002\u0002\u0a04\u0a02\u0003\u0002\u0002',
-  '\u0002\u0a04\u0a05\u0003\u0002\u0002\u0002\u0a05\u0a08\u0003\u0002\u0002',
-  '\u0002\u0a06\u0a04\u0003\u0002\u0002\u0002\u0a07\u0a09\u0007\u0099\u0002',
-  '\u0002\u0a08\u0a07\u0003\u0002\u0002\u0002\u0a08\u0a09\u0003\u0002\u0002',
-  '\u0002\u0a09\u0a0a\u0003\u0002\u0002\u0002\u0a0a\u0a0b\u0007\u0012\u0002',
-  '\u0002\u0a0b\u016d\u0003\u0002\u0002\u0002\u0a0c\u0a11\u0005\u0170\u00b9',
-  '\u0002\u0a0d\u0a11\u0005\u0172\u00ba\u0002\u0a0e\u0a11\u0005\u0174\u00bb',
-  '\u0002\u0a0f\u0a11\u0005\u0176\u00bc\u0002\u0a10\u0a0c\u0003\u0002\u0002',
-  '\u0002\u0a10\u0a0d\u0003\u0002\u0002\u0002\u0a10\u0a0e\u0003\u0002\u0002',
-  '\u0002\u0a10\u0a0f\u0003\u0002\u0002\u0002\u0a11\u016f\u0003\u0002\u0002',
-  '\u0002\u0a12\u0a14\u0005\u0186\u00c4\u0002\u0a13\u0a15\u0007\u0099\u0002',
-  '\u0002\u0a14\u0a13\u0003\u0002\u0002\u0002\u0a14\u0a15\u0003\u0002\u0002',
-  '\u0002\u0a15\u0a16\u0003\u0002\u0002\u0002\u0a16\u0a18\u0007\u0004\u0002',
-  '\u0002\u0a17\u0a19\u0007\u0099\u0002\u0002\u0a18\u0a17\u0003\u0002\u0002',
-  '\u0002\u0a18\u0a19\u0003\u0002\u0002\u0002\u0a19\u0a1a\u0003\u0002\u0002',
-  '\u0002\u0a1a\u0a1b\u0005\u0102\u0082\u0002\u0a1b\u0171\u0003\u0002\u0002',
-  '\u0002\u0a1c\u0a1d\u0007\t\u0002\u0002\u0a1d\u0a1e\u0005\u0166\u00b4',
-  '\u0002\u0a1e\u0173\u0003\u0002\u0002\u0002\u0a1f\u0a20\u0005\u0166\u00b4',
-  '\u0002\u0a20\u0175\u0003\u0002\u0002\u0002\u0a21\u0a22\u0007\t\u0002',
-  '\u0002\u0a22\u0a23\u0007\u0019\u0002\u0002\u0a23\u0177\u0003\u0002\u0002',
-  '\u0002\u0a24\u0a27\u0005\u017a\u00be\u0002\u0a25\u0a27\u0005\u017c\u00bf',
-  '\u0002\u0a26\u0a24\u0003\u0002\u0002\u0002\u0a26\u0a25\u0003\u0002\u0002',
-  '\u0002\u0a27\u0179\u0003\u0002\u0002\u0002\u0a28\u0a2a\u0007\u0010\u0002',
-  '\u0002\u0a29\u0a2b\u0007\u0099\u0002\u0002\u0a2a\u0a29\u0003\u0002\u0002',
-  '\u0002\u0a2a\u0a2b\u0003\u0002\u0002\u0002\u0a2b\u0a2c\u0003\u0002\u0002',
-  '\u0002\u0a2c\u0a2e\u0005\u017e\u00c0\u0002\u0a2d\u0a2f\u0007\u0099\u0002',
-  '\u0002\u0a2e\u0a2d\u0003\u0002\u0002\u0002\u0a2e\u0a2f\u0003\u0002\u0002',
-  '\u0002\u0a2f\u0a30\u0003\u0002\u0002\u0002\u0a30\u0a31\u0007\u0012\u0002',
-  '\u0002\u0a31\u017b\u0003\u0002\u0002\u0002\u0a32\u0a33\u0007$\u0002',
-  '\u0002\u0a33\u0a34\u0005\u017e\u00c0\u0002\u0a34\u017d\u0003\u0002\u0002',
-  '\u0002\u0a35\u0a38\u0005\u0194\u00cb\u0002\u0a36\u0a38\u0007\u008a\u0002',
-  '\u0002\u0a37\u0a35\u0003\u0002\u0002\u0002\u0a37\u0a36\u0003\u0002\u0002',
-  '\u0002\u0a38\u017f\u0003\u0002\u0002\u0002\u0a39\u0a44\u0005\u0182\u00c2',
-  '\u0002\u0a3a\u0a3c\u0007\u0099\u0002\u0002\u0a3b\u0a3a\u0003\u0002\u0002',
-  '\u0002\u0a3b\u0a3c\u0003\u0002\u0002\u0002\u0a3c\u0a3d\u0003\u0002\u0002',
-  '\u0002\u0a3d\u0a3f\u0007\u0011\u0002\u0002\u0a3e\u0a40\u0007\u0099\u0002',
-  '\u0002\u0a3f\u0a3e\u0003\u0002\u0002\u0002\u0a3f\u0a40\u0003\u0002\u0002',
-  '\u0002\u0a40\u0a41\u0003\u0002\u0002\u0002\u0a41\u0a43\u0005\u0182\u00c2',
-  '\u0002\u0a42\u0a3b\u0003\u0002\u0002\u0002\u0a43\u0a46\u0003\u0002\u0002',
-  '\u0002\u0a44\u0a42\u0003\u0002\u0002\u0002\u0a44\u0a45\u0003\u0002\u0002',
-  '\u0002\u0a45\u0181\u0003\u0002\u0002\u0002\u0a46\u0a44\u0003\u0002\u0002',
-  '\u0002\u0a47\u0a4c\u0005\u0140\u00a1\u0002\u0a48\u0a4a\u0007\u0099\u0002',
-  '\u0002\u0a49\u0a48\u0003\u0002\u0002\u0002\u0a49\u0a4a\u0003\u0002\u0002',
-  '\u0002\u0a4a\u0a4b\u0003\u0002\u0002\u0002\u0a4b\u0a4d\u0005\u0160\u00b1',
-  '\u0002\u0a4c\u0a49\u0003\u0002\u0002\u0002\u0a4d\u0a4e\u0003\u0002\u0002',
-  '\u0002\u0a4e\u0a4c\u0003\u0002\u0002\u0002\u0a4e\u0a4f\u0003\u0002\u0002',
-  '\u0002\u0a4f\u0183\u0003\u0002\u0002\u0002\u0a50\u0a5b\u0005\u0186\u00c4',
-  '\u0002\u0a51\u0a53\u0007\u0099\u0002\u0002\u0a52\u0a51\u0003\u0002\u0002',
-  '\u0002\u0a52\u0a53\u0003\u0002\u0002\u0002\u0a53\u0a54\u0003\u0002\u0002',
-  '\u0002\u0a54\u0a56\u0007\u0011\u0002\u0002\u0a55\u0a57\u0007\u0099\u0002',
-  '\u0002\u0a56\u0a55\u0003\u0002\u0002\u0002\u0a56\u0a57\u0003\u0002\u0002',
-  '\u0002\u0a57\u0a58\u0003\u0002\u0002\u0002\u0a58\u0a5a\u0005\u0186\u00c4',
-  '\u0002\u0a59\u0a52\u0003\u0002\u0002\u0002\u0a5a\u0a5d\u0003\u0002\u0002',
-  '\u0002\u0a5b\u0a59\u0003\u0002\u0002\u0002\u0a5b\u0a5c\u0003\u0002\u0002',
-  '\u0002\u0a5c\u0185\u0003\u0002\u0002\u0002\u0a5d\u0a5b\u0003\u0002\u0002',
-  '\u0002\u0a5e\u0a5f\u0005\u0194\u00cb\u0002\u0a5f\u0187\u0003\u0002\u0002',
-  '\u0002\u0a60\u0a61\t\b\u0002\u0002\u0a61\u0189\u0003\u0002\u0002\u0002',
-  '\u0a62\u0a63\t\t\u0002\u0002\u0a63\u018b\u0003\u0002\u0002\u0002\u0a64',
-  '\u0a65\u0005\u0194\u00cb\u0002\u0a65\u0a66\u0007\t\u0002\u0002\u0a66',
-  '\u0a68\u0003\u0002\u0002\u0002\u0a67\u0a64\u0003\u0002\u0002\u0002\u0a68',
-  '\u0a6b\u0003\u0002\u0002\u0002\u0a69\u0a67\u0003\u0002\u0002\u0002\u0a69',
-  '\u0a6a\u0003\u0002\u0002\u0002\u0a6a\u018d\u0003\u0002\u0002\u0002\u0a6b',
-  '\u0a69\u0003\u0002\u0002\u0002\u0a6c\u0a6d\t\n\u0002\u0002\u0a6d\u018f',
-  '\u0003\u0002\u0002\u0002\u0a6e\u0a6f\t\u000b\u0002\u0002\u0a6f\u0191',
-  '\u0003\u0002\u0002\u0002\u0a70\u0a71\t\f\u0002\u0002\u0a71\u0193\u0003',
-  '\u0002\u0002\u0002\u0a72\u0a77\u0005\u0196\u00cc\u0002\u0a73\u0a77\u0007',
-  '\u0095\u0002\u0002\u0a74\u0a77\u0007\u0098\u0002\u0002\u0a75\u0a77\u0007',
-  '\u008c\u0002\u0002\u0a76\u0a72\u0003\u0002\u0002\u0002\u0a76\u0a73\u0003',
-  '\u0002\u0002\u0002\u0a76\u0a74\u0003\u0002\u0002\u0002\u0a76\u0a75\u0003',
-  '\u0002\u0002\u0002\u0a77\u0195\u0003\u0002\u0002\u0002\u0a78\u0a79\t',
-  '\r\u0002\u0002\u0a79\u0197\u0003\u0002\u0002\u0002\u01a6\u019d\u01a1',
-  '\u01a6\u01aa\u01ad\u01b2\u01ba\u01c2\u01cf\u01d3\u01d7\u01e0\u01e5\u01e9',
-  '\u01ec\u01ef\u01f4\u01f8\u01ff\u0211\u0228\u0230\u0232\u0236\u023b\u0241',
-  '\u0247\u024b\u024f\u0253\u0257\u025e\u0261\u0265\u0269\u026f\u0273\u0277',
-  '\u027b\u027f\u0286\u0289\u0291\u029a\u029f\u02a3\u02a6\u02ad\u02b5\u02b9',
-  '\u02bf\u02c4\u02ca\u02d5\u02d9\u02df\u02e3\u02e7\u02ec\u02f1\u02f7\u02fc',
-  '\u0306\u030a\u030f\u0316\u031b\u031e\u032e\u033a\u0368\u036c\u0370\u0374',
-  '\u037c\u0380\u0385\u0389\u0397\u039b\u03a0\u03a4\u03aa\u03ae\u03bc\u03c3',
-  '\u03c9\u03d3\u03d7\u03dd\u03e5\u03f0\u03f6\u0402\u0408\u0414\u0418\u0422',
-  '\u042f\u0433\u0437\u043d\u0441\u0444\u0448\u0452\u0459\u0466\u046a\u0472',
-  '\u0478\u047c\u0480\u0485\u048a\u048e\u0494\u0498\u049e\u04a2\u04a8\u04ac',
-  '\u04b0\u04b4\u04b8\u04bc\u04c1\u04c8\u04cc\u04d1\u04d8\u04dc\u04e0\u04e8',
-  '\u04ef\u04f2\u04f8\u04fb\u0500\u0503\u0507\u050a\u050d\u0514\u0518\u051c',
-  '\u0520\u0524\u0529\u052e\u0532\u0537\u053c\u053f\u0541\u054a\u0550\u0553',
-  '\u0557\u055a\u0561\u0564\u0567\u056b\u0570\u0574\u057c\u0580\u0585\u058a',
-  '\u058e\u05a0\u05a4\u05a9\u05b6\u05ba\u05bc\u05bf\u05c8\u05cc\u05d0\u05dc',
-  '\u05e0\u05e5\u05ef\u05f5\u05f9\u05fe\u0602\u0606\u060a\u0610\u0614\u0619',
-  '\u061f\u0628\u0631\u0639\u063f\u0643\u0648\u0651\u0655\u065a\u065f\u0663',
-  '\u0668\u066c\u0670\u0675\u067c\u0680\u0684\u0686\u068a\u068c\u0690\u0692',
-  '\u0698\u069e\u06a1\u06a4\u06aa\u06af\u06b3\u06b8\u06bc\u06c0\u06c2\u06c6',
-  '\u06c8\u06cb\u06cf\u06d1\u06d7\u06db\u06e1\u06e7\u06ee\u06f4\u06f9\u0701',
-  '\u0705\u0707\u070b\u070f\u0711\u0713\u0722\u072c\u0736\u073b\u073f\u0746',
-  '\u074b\u0750\u0754\u0758\u075c\u075f\u0761\u0766\u076a\u076e\u0772\u0776',
-  '\u077a\u077d\u077f\u0784\u0788\u078d\u0792\u0796\u079d\u07a4\u07a8\u07ac',
-  '\u07b0\u07bf\u07c2\u07cf\u07d1\u07d6\u07da\u07de\u07e3\u07e7\u07eb\u07f3',
-  '\u07f7\u07fb\u0803\u0807\u080b\u0813\u0817\u081b\u0823\u0827\u082b\u0833',
-  '\u0837\u083b\u0843\u0847\u084b\u084f\u0852\u0855\u085d\u0861\u0865\u0869',
-  '\u086d\u0871\u0875\u0879\u087d\u0885\u0889\u088d\u0893\u0897\u089b\u089f',
-  '\u08aa\u08ae\u08b2\u08c4\u08cd\u08d5\u08d9\u08dd\u08e1\u08e5\u08e8\u08ee',
-  '\u08f3\u08f8\u08fd\u0902\u0907\u090c\u090f\u0913\u0917\u091d\u0922\u0926',
-  '\u0929\u0933\u0937\u093b\u093d\u0941\u0945\u0949\u094d\u0950\u095d\u0961',
-  '\u0965\u0968\u096b\u0971\u0975\u0979\u097b\u097f\u0983\u0987\u0989\u098d',
-  '\u0991\u0997\u099d\u09a2\u09a6\u09aa\u09af\u09b1\u09b4\u09b8\u09bb\u09be',
-  '\u09c4\u09c8\u09cc\u09d4\u09d8\u09dc\u09e0\u09e4\u09e8\u09eb\u09f1\u09f5',
-  '\u09f8\u09fb\u09ff\u0a04\u0a08\u0a10\u0a14\u0a18\u0a26\u0a2a\u0a2e\u0a37',
-  '\u0a3b\u0a3f\u0a44\u0a49\u0a4e\u0a52\u0a56\u0a5b\u0a69\u0a76'
-].join('')
-
-var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN)
-
-var decisionsToDFA = atn.decisionToState.map(function(ds, index) {
-  return new antlr4.dfa.DFA(ds, index)
-})
-
-var sharedContextCache = new antlr4.PredictionContextCache()
-
-var literalNames = [
-  null,
-  "';'",
-  "':'",
-  "'-'",
-  "'=>'",
-  "'://'",
-  "'/'",
-  "'.'",
-  "'@'",
-  "'#'",
-  "'?'",
-  "'&'",
-  "'='",
-  "'+'",
-  "'{'",
-  "','",
-  "'}'",
-  "'['",
-  "']'",
-  "'('",
-  "')'",
-  "'+='",
-  "'|'",
-  "'*'",
-  "'..'",
-  "'%'",
-  "'^'",
-  "'=~'",
-  "'<>'",
-  "'!='",
-  "'<'",
-  "'>'",
-  "'<='",
-  "'>='",
-  "'$'",
-  "'\u27E8'",
-  "'\u3008'",
-  "'\uFE64'",
-  "'\uFF1C'",
-  "'\u27E9'",
-  "'\u3009'",
-  "'\uFE65'",
-  "'\uFF1E'",
-  "'\u00AD'",
-  "'\u2010'",
-  "'\u2011'",
-  "'\u2012'",
-  "'\u2013'",
-  "'\u2014'",
-  "'\u2015'",
-  "'\u2212'",
-  "'\uFE58'",
-  "'\uFE63'",
-  "'\uFF0D'",
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  "'0'"
-]
-
-var symbolicNames = [
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  null,
-  'CYPHER',
-  'EXPLAIN',
-  'PROFILE',
-  'USING',
-  'PERIODIC',
-  'COMMIT',
-  'UNION',
-  'ALL',
-  'CREATE',
-  'DROP',
-  'INDEX',
-  'ON',
-  'CONSTRAINT',
-  'ASSERT',
-  'IS',
-  'UNIQUE',
-  'EXISTS',
-  'LOAD',
-  'CSV',
-  'WITH',
-  'HEADERS',
-  'FROM',
-  'AS',
-  'FIELDTERMINATOR',
-  'OPTIONAL',
-  'MATCH',
-  'UNWIND',
-  'MERGE',
-  'SET',
-  'DETACH',
-  'DELETE',
-  'REMOVE',
-  'FOREACH',
-  'IN',
-  'DISTINCT',
-  'RETURN',
-  'ORDER',
-  'BY',
-  'L_SKIP',
-  'LIMIT',
-  'ASCENDING',
-  'ASC',
-  'DESCENDING',
-  'DESC',
-  'JOIN',
-  'SCAN',
-  'START',
-  'NODE',
-  'RELATIONSHIP',
-  'REL',
-  'WHERE',
-  'SHORTESTPATH',
-  'ALLSHORTESTPATHS',
-  'OR',
-  'XOR',
-  'AND',
-  'NOT',
-  'STARTS',
-  'ENDS',
-  'CONTAINS',
-  'NULL',
-  'COUNT',
-  'FILTER',
-  'EXTRACT',
-  'ANY',
-  'NONE',
-  'SINGLE',
-  'TRUE',
-  'FALSE',
-  'REDUCE',
-  'CASE',
-  'ELSE',
-  'END',
-  'WHEN',
-  'THEN',
-  'CALL',
-  'YIELD',
-  'KEY',
-  'StringLiteral',
-  'UrlHex',
-  'EscapedChar',
-  'HexInteger',
-  'DecimalInteger',
-  'OctalInteger',
-  'HexLetter',
-  'HexDigit',
-  'Digit',
-  'NonZeroDigit',
-  'NonZeroOctDigit',
-  'OctDigit',
-  'ZeroDigit',
-  'ExponentDecimalReal',
-  'RegularDecimalReal',
-  'UnescapedSymbolicName',
-  'IdentifierStart',
-  'IdentifierPart',
-  'EscapedSymbolicName',
-  'SP',
-  'WHITESPACE',
-  'Comment',
-  'ERROR_TOKEN'
-]
-
-var ruleNames = [
-  'cypher',
-  'cypherPart',
-  'cypherConsoleCommand',
-  'cypherConsoleCommandName',
-  'cypherConsoleCommandParameters',
-  'cypherConsoleCommandParameter',
-  'arrowExpression',
-  'url',
-  'uri',
-  'scheme',
-  'host',
-  'hostname',
-  'hostnumber',
-  'port',
-  'path',
-  'user',
-  'login',
-  'password',
-  'frag',
-  'urlQuery',
-  'search',
-  'searchparameter',
-  'string',
-  'urlDigits',
-  'json',
-  'obj',
-  'pair',
-  'array',
-  'value',
-  'keyValueLiteral',
-  'commandPath',
-  'subCommand',
-  'cypherQuery',
-  'queryOptions',
-  'anyCypherOption',
-  'cypherOption',
-  'versionNumber',
-  'explain',
-  'profile',
-  'configurationOption',
-  'statement',
-  'query',
-  'regularQuery',
-  'bulkImportQuery',
-  'singleQuery',
-  'periodicCommitHint',
-  'loadCSVQuery',
-  'union',
-  'clause',
-  'command',
-  'createUniqueConstraint',
-  'createNodeKeyConstraint',
-  'createNodePropertyExistenceConstraint',
-  'createRelationshipPropertyExistenceConstraint',
-  'createIndex',
-  'dropUniqueConstraint',
-  'dropNodeKeyConstraint',
-  'dropNodePropertyExistenceConstraint',
-  'dropRelationshipPropertyExistenceConstraint',
-  'dropIndex',
-  'index',
-  'uniqueConstraint',
-  'nodeKeyConstraint',
-  'nodePropertyExistenceConstraint',
-  'relationshipPropertyExistenceConstraint',
-  'relationshipPatternSyntax',
-  'loadCSVClause',
-  'matchClause',
-  'unwindClause',
-  'mergeClause',
-  'mergeAction',
-  'createClause',
-  'createUniqueClause',
-  'setClause',
-  'setItem',
-  'deleteClause',
-  'removeClause',
-  'removeItem',
-  'foreachClause',
-  'withClause',
-  'returnClause',
-  'returnBody',
-  'returnItems',
-  'returnItem',
-  'call',
-  'procedureInvocation',
-  'procedureInvocationBody',
-  'procedureArguments',
-  'procedureResults',
-  'procedureResult',
-  'aliasedProcedureResult',
-  'simpleProcedureResult',
-  'procedureOutput',
-  'order',
-  'skip',
-  'limit',
-  'sortItem',
-  'hint',
-  'startClause',
-  'startPoint',
-  'lookup',
-  'nodeLookup',
-  'relationshipLookup',
-  'identifiedIndexLookup',
-  'indexQuery',
-  'idLookup',
-  'literalIds',
-  'where',
-  'pattern',
-  'patternPart',
-  'anonymousPatternPart',
-  'patternElement',
-  'nodePattern',
-  'patternElementChain',
-  'relationshipPattern',
-  'relationshipPatternStart',
-  'relationshipPatternEnd',
-  'relationshipDetail',
-  'properties',
-  'relType',
-  'relationshipTypes',
-  'relationshipType',
-  'relationshipTypeOptionalColon',
-  'nodeLabels',
-  'nodeLabel',
-  'rangeLiteral',
-  'labelName',
-  'relTypeName',
-  'expression',
-  'orExpression',
-  'xorExpression',
-  'andExpression',
-  'notExpression',
-  'comparisonExpression',
-  'addOrSubtractExpression',
-  'multiplyDivideModuloExpression',
-  'powerOfExpression',
-  'unaryAddOrSubtractExpression',
-  'stringListNullOperatorExpression',
-  'propertyOrLabelsExpression',
-  'filterFunction',
-  'filterFunctionName',
-  'existsFunction',
-  'existsFunctionName',
-  'allFunction',
-  'allFunctionName',
-  'anyFunction',
-  'anyFunctionName',
-  'noneFunction',
-  'noneFunctionName',
-  'singleFunction',
-  'singleFunctionName',
-  'extractFunction',
-  'extractFunctionName',
-  'reduceFunction',
-  'reduceFunctionName',
-  'shortestPathPatternFunction',
-  'shortestPathFunctionName',
-  'allShortestPathFunctionName',
-  'atom',
-  'literal',
-  'stringLiteral',
-  'booleanLiteral',
-  'listLiteral',
-  'partialComparisonExpression',
-  'parenthesizedExpression',
-  'relationshipsPattern',
-  'filterExpression',
-  'idInColl',
-  'functionInvocation',
-  'functionInvocationBody',
-  'functionName',
-  'procedureName',
-  'listComprehension',
-  'patternComprehension',
-  'propertyLookup',
-  'caseExpression',
-  'caseAlternatives',
-  'variable',
-  'numberLiteral',
-  'mapLiteral',
-  'mapProjection',
-  'mapProjectionVariants',
-  'literalEntry',
-  'propertySelector',
-  'variableSelector',
-  'allPropertiesSelector',
-  'parameter',
-  'legacyParameter',
-  'newParameter',
-  'parameterName',
-  'propertyExpressions',
-  'propertyExpression',
-  'propertyKeys',
-  'propertyKeyName',
-  'integerLiteral',
-  'doubleLiteral',
-  'namespace',
-  'leftArrowHead',
-  'rightArrowHead',
-  'dash',
-  'symbolicName',
-  'keyword'
-]
-
-function CypherParser(input) {
-  antlr4.Parser.call(this, input)
-  this._interp = new antlr4.atn.ParserATNSimulator(
-    this,
-    atn,
-    decisionsToDFA,
-    sharedContextCache
-  )
-  this.ruleNames = ruleNames
-  this.literalNames = literalNames
-  this.symbolicNames = symbolicNames
-  return this
-}
-
-CypherParser.prototype = Object.create(antlr4.Parser.prototype)
-CypherParser.prototype.constructor = CypherParser
-
-Object.defineProperty(CypherParser.prototype, 'atn', {
-  get: function() {
-    return atn
-  }
-})
-
-CypherParser.EOF = antlr4.Token.EOF
-CypherParser.T__0 = 1
-CypherParser.T__1 = 2
-CypherParser.T__2 = 3
-CypherParser.T__3 = 4
-CypherParser.T__4 = 5
-CypherParser.T__5 = 6
-CypherParser.T__6 = 7
-CypherParser.T__7 = 8
-CypherParser.T__8 = 9
-CypherParser.T__9 = 10
-CypherParser.T__10 = 11
-CypherParser.T__11 = 12
-CypherParser.T__12 = 13
-CypherParser.T__13 = 14
-CypherParser.T__14 = 15
-CypherParser.T__15 = 16
-CypherParser.T__16 = 17
-CypherParser.T__17 = 18
-CypherParser.T__18 = 19
-CypherParser.T__19 = 20
-CypherParser.T__20 = 21
-CypherParser.T__21 = 22
-CypherParser.T__22 = 23
-CypherParser.T__23 = 24
-CypherParser.T__24 = 25
-CypherParser.T__25 = 26
-CypherParser.T__26 = 27
-CypherParser.T__27 = 28
-CypherParser.T__28 = 29
-CypherParser.T__29 = 30
-CypherParser.T__30 = 31
-CypherParser.T__31 = 32
-CypherParser.T__32 = 33
-CypherParser.T__33 = 34
-CypherParser.T__34 = 35
-CypherParser.T__35 = 36
-CypherParser.T__36 = 37
-CypherParser.T__37 = 38
-CypherParser.T__38 = 39
-CypherParser.T__39 = 40
-CypherParser.T__40 = 41
-CypherParser.T__41 = 42
-CypherParser.T__42 = 43
-CypherParser.T__43 = 44
-CypherParser.T__44 = 45
-CypherParser.T__45 = 46
-CypherParser.T__46 = 47
-CypherParser.T__47 = 48
-CypherParser.T__48 = 49
-CypherParser.T__49 = 50
-CypherParser.T__50 = 51
-CypherParser.T__51 = 52
-CypherParser.T__52 = 53
-CypherParser.CYPHER = 54
-CypherParser.EXPLAIN = 55
-CypherParser.PROFILE = 56
-CypherParser.USING = 57
-CypherParser.PERIODIC = 58
-CypherParser.COMMIT = 59
-CypherParser.UNION = 60
-CypherParser.ALL = 61
-CypherParser.CREATE = 62
-CypherParser.DROP = 63
-CypherParser.INDEX = 64
-CypherParser.ON = 65
-CypherParser.CONSTRAINT = 66
-CypherParser.ASSERT = 67
-CypherParser.IS = 68
-CypherParser.UNIQUE = 69
-CypherParser.EXISTS = 70
-CypherParser.LOAD = 71
-CypherParser.CSV = 72
-CypherParser.WITH = 73
-CypherParser.HEADERS = 74
-CypherParser.FROM = 75
-CypherParser.AS = 76
-CypherParser.FIELDTERMINATOR = 77
-CypherParser.OPTIONAL = 78
-CypherParser.MATCH = 79
-CypherParser.UNWIND = 80
-CypherParser.MERGE = 81
-CypherParser.SET = 82
-CypherParser.DETACH = 83
-CypherParser.DELETE = 84
-CypherParser.REMOVE = 85
-CypherParser.FOREACH = 86
-CypherParser.IN = 87
-CypherParser.DISTINCT = 88
-CypherParser.RETURN = 89
-CypherParser.ORDER = 90
-CypherParser.BY = 91
-CypherParser.L_SKIP = 92
-CypherParser.LIMIT = 93
-CypherParser.ASCENDING = 94
-CypherParser.ASC = 95
-CypherParser.DESCENDING = 96
-CypherParser.DESC = 97
-CypherParser.JOIN = 98
-CypherParser.SCAN = 99
-CypherParser.START = 100
-CypherParser.NODE = 101
-CypherParser.RELATIONSHIP = 102
-CypherParser.REL = 103
-CypherParser.WHERE = 104
-CypherParser.SHORTESTPATH = 105
-CypherParser.ALLSHORTESTPATHS = 106
-CypherParser.OR = 107
-CypherParser.XOR = 108
-CypherParser.AND = 109
-CypherParser.NOT = 110
-CypherParser.STARTS = 111
-CypherParser.ENDS = 112
-CypherParser.CONTAINS = 113
-CypherParser.NULL = 114
-CypherParser.COUNT = 115
-CypherParser.FILTER = 116
-CypherParser.EXTRACT = 117
-CypherParser.ANY = 118
-CypherParser.NONE = 119
-CypherParser.SINGLE = 120
-CypherParser.TRUE = 121
-CypherParser.FALSE = 122
-CypherParser.REDUCE = 123
-CypherParser.CASE = 124
-CypherParser.ELSE = 125
-CypherParser.END = 126
-CypherParser.WHEN = 127
-CypherParser.THEN = 128
-CypherParser.CALL = 129
-CypherParser.YIELD = 130
-CypherParser.KEY = 131
-CypherParser.StringLiteral = 132
-CypherParser.UrlHex = 133
-CypherParser.EscapedChar = 134
-CypherParser.HexInteger = 135
-CypherParser.DecimalInteger = 136
-CypherParser.OctalInteger = 137
-CypherParser.HexLetter = 138
-CypherParser.HexDigit = 139
-CypherParser.Digit = 140
-CypherParser.NonZeroDigit = 141
-CypherParser.NonZeroOctDigit = 142
-CypherParser.OctDigit = 143
-CypherParser.ZeroDigit = 144
-CypherParser.ExponentDecimalReal = 145
-CypherParser.RegularDecimalReal = 146
-CypherParser.UnescapedSymbolicName = 147
-CypherParser.IdentifierStart = 148
-CypherParser.IdentifierPart = 149
-CypherParser.EscapedSymbolicName = 150
-CypherParser.SP = 151
-CypherParser.WHITESPACE = 152
-CypherParser.Comment = 153
-CypherParser.ERROR_TOKEN = 154
-
-CypherParser.RULE_cypher = 0
-CypherParser.RULE_cypherPart = 1
-CypherParser.RULE_cypherConsoleCommand = 2
-CypherParser.RULE_cypherConsoleCommandName = 3
-CypherParser.RULE_cypherConsoleCommandParameters = 4
-CypherParser.RULE_cypherConsoleCommandParameter = 5
-CypherParser.RULE_arrowExpression = 6
-CypherParser.RULE_url = 7
-CypherParser.RULE_uri = 8
-CypherParser.RULE_scheme = 9
-CypherParser.RULE_host = 10
-CypherParser.RULE_hostname = 11
-CypherParser.RULE_hostnumber = 12
-CypherParser.RULE_port = 13
-CypherParser.RULE_path = 14
-CypherParser.RULE_user = 15
-CypherParser.RULE_login = 16
-CypherParser.RULE_password = 17
-CypherParser.RULE_frag = 18
-CypherParser.RULE_urlQuery = 19
-CypherParser.RULE_search = 20
-CypherParser.RULE_searchparameter = 21
-CypherParser.RULE_string = 22
-CypherParser.RULE_urlDigits = 23
-CypherParser.RULE_json = 24
-CypherParser.RULE_obj = 25
-CypherParser.RULE_pair = 26
-CypherParser.RULE_array = 27
-CypherParser.RULE_value = 28
-CypherParser.RULE_keyValueLiteral = 29
-CypherParser.RULE_commandPath = 30
-CypherParser.RULE_subCommand = 31
-CypherParser.RULE_cypherQuery = 32
-CypherParser.RULE_queryOptions = 33
-CypherParser.RULE_anyCypherOption = 34
-CypherParser.RULE_cypherOption = 35
-CypherParser.RULE_versionNumber = 36
-CypherParser.RULE_explain = 37
-CypherParser.RULE_profile = 38
-CypherParser.RULE_configurationOption = 39
-CypherParser.RULE_statement = 40
-CypherParser.RULE_query = 41
-CypherParser.RULE_regularQuery = 42
-CypherParser.RULE_bulkImportQuery = 43
-CypherParser.RULE_singleQuery = 44
-CypherParser.RULE_periodicCommitHint = 45
-CypherParser.RULE_loadCSVQuery = 46
-CypherParser.RULE_union = 47
-CypherParser.RULE_clause = 48
-CypherParser.RULE_command = 49
-CypherParser.RULE_createUniqueConstraint = 50
-CypherParser.RULE_createNodeKeyConstraint = 51
-CypherParser.RULE_createNodePropertyExistenceConstraint = 52
-CypherParser.RULE_createRelationshipPropertyExistenceConstraint = 53
-CypherParser.RULE_createIndex = 54
-CypherParser.RULE_dropUniqueConstraint = 55
-CypherParser.RULE_dropNodeKeyConstraint = 56
-CypherParser.RULE_dropNodePropertyExistenceConstraint = 57
-CypherParser.RULE_dropRelationshipPropertyExistenceConstraint = 58
-CypherParser.RULE_dropIndex = 59
-CypherParser.RULE_index = 60
-CypherParser.RULE_uniqueConstraint = 61
-CypherParser.RULE_nodeKeyConstraint = 62
-CypherParser.RULE_nodePropertyExistenceConstraint = 63
-CypherParser.RULE_relationshipPropertyExistenceConstraint = 64
-CypherParser.RULE_relationshipPatternSyntax = 65
-CypherParser.RULE_loadCSVClause = 66
-CypherParser.RULE_matchClause = 67
-CypherParser.RULE_unwindClause = 68
-CypherParser.RULE_mergeClause = 69
-CypherParser.RULE_mergeAction = 70
-CypherParser.RULE_createClause = 71
-CypherParser.RULE_createUniqueClause = 72
-CypherParser.RULE_setClause = 73
-CypherParser.RULE_setItem = 74
-CypherParser.RULE_deleteClause = 75
-CypherParser.RULE_removeClause = 76
-CypherParser.RULE_removeItem = 77
-CypherParser.RULE_foreachClause = 78
-CypherParser.RULE_withClause = 79
-CypherParser.RULE_returnClause = 80
-CypherParser.RULE_returnBody = 81
-CypherParser.RULE_returnItems = 82
-CypherParser.RULE_returnItem = 83
-CypherParser.RULE_call = 84
-CypherParser.RULE_procedureInvocation = 85
-CypherParser.RULE_procedureInvocationBody = 86
-CypherParser.RULE_procedureArguments = 87
-CypherParser.RULE_procedureResults = 88
-CypherParser.RULE_procedureResult = 89
-CypherParser.RULE_aliasedProcedureResult = 90
-CypherParser.RULE_simpleProcedureResult = 91
-CypherParser.RULE_procedureOutput = 92
-CypherParser.RULE_order = 93
-CypherParser.RULE_skip = 94
-CypherParser.RULE_limit = 95
-CypherParser.RULE_sortItem = 96
-CypherParser.RULE_hint = 97
-CypherParser.RULE_startClause = 98
-CypherParser.RULE_startPoint = 99
-CypherParser.RULE_lookup = 100
-CypherParser.RULE_nodeLookup = 101
-CypherParser.RULE_relationshipLookup = 102
-CypherParser.RULE_identifiedIndexLookup = 103
-CypherParser.RULE_indexQuery = 104
-CypherParser.RULE_idLookup = 105
-CypherParser.RULE_literalIds = 106
-CypherParser.RULE_where = 107
-CypherParser.RULE_pattern = 108
-CypherParser.RULE_patternPart = 109
-CypherParser.RULE_anonymousPatternPart = 110
-CypherParser.RULE_patternElement = 111
-CypherParser.RULE_nodePattern = 112
-CypherParser.RULE_patternElementChain = 113
-CypherParser.RULE_relationshipPattern = 114
-CypherParser.RULE_relationshipPatternStart = 115
-CypherParser.RULE_relationshipPatternEnd = 116
-CypherParser.RULE_relationshipDetail = 117
-CypherParser.RULE_properties = 118
-CypherParser.RULE_relType = 119
-CypherParser.RULE_relationshipTypes = 120
-CypherParser.RULE_relationshipType = 121
-CypherParser.RULE_relationshipTypeOptionalColon = 122
-CypherParser.RULE_nodeLabels = 123
-CypherParser.RULE_nodeLabel = 124
-CypherParser.RULE_rangeLiteral = 125
-CypherParser.RULE_labelName = 126
-CypherParser.RULE_relTypeName = 127
-CypherParser.RULE_expression = 128
-CypherParser.RULE_orExpression = 129
-CypherParser.RULE_xorExpression = 130
-CypherParser.RULE_andExpression = 131
-CypherParser.RULE_notExpression = 132
-CypherParser.RULE_comparisonExpression = 133
-CypherParser.RULE_addOrSubtractExpression = 134
-CypherParser.RULE_multiplyDivideModuloExpression = 135
-CypherParser.RULE_powerOfExpression = 136
-CypherParser.RULE_unaryAddOrSubtractExpression = 137
-CypherParser.RULE_stringListNullOperatorExpression = 138
-CypherParser.RULE_propertyOrLabelsExpression = 139
-CypherParser.RULE_filterFunction = 140
-CypherParser.RULE_filterFunctionName = 141
-CypherParser.RULE_existsFunction = 142
-CypherParser.RULE_existsFunctionName = 143
-CypherParser.RULE_allFunction = 144
-CypherParser.RULE_allFunctionName = 145
-CypherParser.RULE_anyFunction = 146
-CypherParser.RULE_anyFunctionName = 147
-CypherParser.RULE_noneFunction = 148
-CypherParser.RULE_noneFunctionName = 149
-CypherParser.RULE_singleFunction = 150
-CypherParser.RULE_singleFunctionName = 151
-CypherParser.RULE_extractFunction = 152
-CypherParser.RULE_extractFunctionName = 153
-CypherParser.RULE_reduceFunction = 154
-CypherParser.RULE_reduceFunctionName = 155
-CypherParser.RULE_shortestPathPatternFunction = 156
-CypherParser.RULE_shortestPathFunctionName = 157
-CypherParser.RULE_allShortestPathFunctionName = 158
-CypherParser.RULE_atom = 159
-CypherParser.RULE_literal = 160
-CypherParser.RULE_stringLiteral = 161
-CypherParser.RULE_booleanLiteral = 162
-CypherParser.RULE_listLiteral = 163
-CypherParser.RULE_partialComparisonExpression = 164
-CypherParser.RULE_parenthesizedExpression = 165
-CypherParser.RULE_relationshipsPattern = 166
-CypherParser.RULE_filterExpression = 167
-CypherParser.RULE_idInColl = 168
-CypherParser.RULE_functionInvocation = 169
-CypherParser.RULE_functionInvocationBody = 170
-CypherParser.RULE_functionName = 171
-CypherParser.RULE_procedureName = 172
-CypherParser.RULE_listComprehension = 173
-CypherParser.RULE_patternComprehension = 174
-CypherParser.RULE_propertyLookup = 175
-CypherParser.RULE_caseExpression = 176
-CypherParser.RULE_caseAlternatives = 177
-CypherParser.RULE_variable = 178
-CypherParser.RULE_numberLiteral = 179
-CypherParser.RULE_mapLiteral = 180
-CypherParser.RULE_mapProjection = 181
-CypherParser.RULE_mapProjectionVariants = 182
-CypherParser.RULE_literalEntry = 183
-CypherParser.RULE_propertySelector = 184
-CypherParser.RULE_variableSelector = 185
-CypherParser.RULE_allPropertiesSelector = 186
-CypherParser.RULE_parameter = 187
-CypherParser.RULE_legacyParameter = 188
-CypherParser.RULE_newParameter = 189
-CypherParser.RULE_parameterName = 190
-CypherParser.RULE_propertyExpressions = 191
-CypherParser.RULE_propertyExpression = 192
-CypherParser.RULE_propertyKeys = 193
-CypherParser.RULE_propertyKeyName = 194
-CypherParser.RULE_integerLiteral = 195
-CypherParser.RULE_doubleLiteral = 196
-CypherParser.RULE_namespace = 197
-CypherParser.RULE_leftArrowHead = 198
-CypherParser.RULE_rightArrowHead = 199
-CypherParser.RULE_dash = 200
-CypherParser.RULE_symbolicName = 201
-CypherParser.RULE_keyword = 202
-
-function CypherContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypher
-  return this
-}
-
-CypherContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-CypherContext.prototype.constructor = CypherContext
-
-CypherContext.prototype.cypherPart = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(CypherPartContext)
-  } else {
-    return this.getTypedRuleContext(CypherPartContext, i)
-  }
-}
-
-CypherContext.prototype.EOF = function() {
-  return this.getToken(CypherParser.EOF, 0)
-}
-
-CypherContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypher(this)
-  }
-}
-
-CypherContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypher(this)
-  }
-}
-
-CypherParser.CypherContext = CypherContext
-
-CypherParser.prototype.cypher = function() {
-  var localctx = new CypherContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 0, CypherParser.RULE_cypher)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 406
-    this.cypherPart()
-    this.state = 411
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 0, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 407
-        this.match(CypherParser.T__0)
-        this.state = 408
-        this.cypherPart()
-      }
-      this.state = 413
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 0, this._ctx)
-    }
-
-    this.state = 415
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__0) {
-      this.state = 414
-      this.match(CypherParser.T__0)
-    }
-
-    this.state = 417
-    this.match(CypherParser.EOF)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CypherPartContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypherPart
-  return this
-}
-
-CypherPartContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-CypherPartContext.prototype.constructor = CypherPartContext
-
-CypherPartContext.prototype.cypherQuery = function() {
-  return this.getTypedRuleContext(CypherQueryContext, 0)
-}
-
-CypherPartContext.prototype.cypherConsoleCommand = function() {
-  return this.getTypedRuleContext(CypherConsoleCommandContext, 0)
-}
-
-CypherPartContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-CypherPartContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypherPart(this)
-  }
-}
-
-CypherPartContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypherPart(this)
-  }
-}
-
-CypherParser.CypherPartContext = CypherPartContext
-
-CypherParser.prototype.cypherPart = function() {
-  var localctx = new CypherPartContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 2, CypherParser.RULE_cypherPart)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 420
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 419
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 424
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.CYPHER:
-      case CypherParser.EXPLAIN:
-      case CypherParser.PROFILE:
-      case CypherParser.USING:
-      case CypherParser.CREATE:
-      case CypherParser.DROP:
-      case CypherParser.LOAD:
-      case CypherParser.WITH:
-      case CypherParser.OPTIONAL:
-      case CypherParser.MATCH:
-      case CypherParser.UNWIND:
-      case CypherParser.MERGE:
-      case CypherParser.SET:
-      case CypherParser.DETACH:
-      case CypherParser.DELETE:
-      case CypherParser.REMOVE:
-      case CypherParser.FOREACH:
-      case CypherParser.RETURN:
-      case CypherParser.START:
-      case CypherParser.CALL:
-        this.state = 422
-        this.cypherQuery()
-        break
-      case CypherParser.T__1:
-        this.state = 423
-        this.cypherConsoleCommand()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-    this.state = 427
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 426
-      this.match(CypherParser.SP)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CypherConsoleCommandContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypherConsoleCommand
-  return this
-}
-
-CypherConsoleCommandContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CypherConsoleCommandContext.prototype.constructor = CypherConsoleCommandContext
-
-CypherConsoleCommandContext.prototype.cypherConsoleCommandName = function() {
-  return this.getTypedRuleContext(CypherConsoleCommandNameContext, 0)
-}
-
-CypherConsoleCommandContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-CypherConsoleCommandContext.prototype.cypherConsoleCommandParameters = function() {
-  return this.getTypedRuleContext(CypherConsoleCommandParametersContext, 0)
-}
-
-CypherConsoleCommandContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypherConsoleCommand(this)
-  }
-}
-
-CypherConsoleCommandContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypherConsoleCommand(this)
-  }
-}
-
-CypherParser.CypherConsoleCommandContext = CypherConsoleCommandContext
-
-CypherParser.prototype.cypherConsoleCommand = function() {
-  var localctx = new CypherConsoleCommandContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 4, CypherParser.RULE_cypherConsoleCommand)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 429
-    this.cypherConsoleCommandName()
-    this.state = 432
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 5, this._ctx)
-    if (la_ === 1) {
-      this.state = 430
-      this.match(CypherParser.SP)
-      this.state = 431
-      this.cypherConsoleCommandParameters()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CypherConsoleCommandNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypherConsoleCommandName
-  return this
-}
-
-CypherConsoleCommandNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CypherConsoleCommandNameContext.prototype.constructor = CypherConsoleCommandNameContext
-
-CypherConsoleCommandNameContext.prototype.symbolicName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SymbolicNameContext)
-  } else {
-    return this.getTypedRuleContext(SymbolicNameContext, i)
-  }
-}
-
-CypherConsoleCommandNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypherConsoleCommandName(this)
-  }
-}
-
-CypherConsoleCommandNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypherConsoleCommandName(this)
-  }
-}
-
-CypherParser.CypherConsoleCommandNameContext = CypherConsoleCommandNameContext
-
-CypherParser.prototype.cypherConsoleCommandName = function() {
-  var localctx = new CypherConsoleCommandNameContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 6, CypherParser.RULE_cypherConsoleCommandName)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 434
-    this.match(CypherParser.T__1)
-    this.state = 435
-    this.symbolicName()
-    this.state = 440
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (_la === CypherParser.T__2) {
-      this.state = 436
-      this.match(CypherParser.T__2)
-      this.state = 437
-      this.symbolicName()
-      this.state = 442
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CypherConsoleCommandParametersContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypherConsoleCommandParameters
-  return this
-}
-
-CypherConsoleCommandParametersContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CypherConsoleCommandParametersContext.prototype.constructor = CypherConsoleCommandParametersContext
-
-CypherConsoleCommandParametersContext.prototype.cypherConsoleCommandParameter = function(
-  i
-) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(CypherConsoleCommandParameterContext)
-  } else {
-    return this.getTypedRuleContext(CypherConsoleCommandParameterContext, i)
-  }
-}
-
-CypherConsoleCommandParametersContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-CypherConsoleCommandParametersContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypherConsoleCommandParameters(this)
-  }
-}
-
-CypherConsoleCommandParametersContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypherConsoleCommandParameters(this)
-  }
-}
-
-CypherParser.CypherConsoleCommandParametersContext = CypherConsoleCommandParametersContext
-
-CypherParser.prototype.cypherConsoleCommandParameters = function() {
-  var localctx = new CypherConsoleCommandParametersContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 8, CypherParser.RULE_cypherConsoleCommandParameters)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 443
-    this.cypherConsoleCommandParameter()
-    this.state = 448
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 7, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 444
-        this.match(CypherParser.SP)
-        this.state = 445
-        this.cypherConsoleCommandParameter()
-      }
-      this.state = 450
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 7, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CypherConsoleCommandParameterContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypherConsoleCommandParameter
-  return this
-}
-
-CypherConsoleCommandParameterContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CypherConsoleCommandParameterContext.prototype.constructor = CypherConsoleCommandParameterContext
-
-CypherConsoleCommandParameterContext.prototype.url = function() {
-  return this.getTypedRuleContext(UrlContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.json = function() {
-  return this.getTypedRuleContext(JsonContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.arrowExpression = function() {
-  return this.getTypedRuleContext(ArrowExpressionContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.mapLiteral = function() {
-  return this.getTypedRuleContext(MapLiteralContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.keyValueLiteral = function() {
-  return this.getTypedRuleContext(KeyValueLiteralContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.stringLiteral = function() {
-  return this.getTypedRuleContext(StringLiteralContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.numberLiteral = function() {
-  return this.getTypedRuleContext(NumberLiteralContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.booleanLiteral = function() {
-  return this.getTypedRuleContext(BooleanLiteralContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.subCommand = function() {
-  return this.getTypedRuleContext(SubCommandContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.commandPath = function() {
-  return this.getTypedRuleContext(CommandPathContext, 0)
-}
-
-CypherConsoleCommandParameterContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypherConsoleCommandParameter(this)
-  }
-}
-
-CypherConsoleCommandParameterContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypherConsoleCommandParameter(this)
-  }
-}
-
-CypherParser.CypherConsoleCommandParameterContext = CypherConsoleCommandParameterContext
-
-CypherParser.prototype.cypherConsoleCommandParameter = function() {
-  var localctx = new CypherConsoleCommandParameterContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 10, CypherParser.RULE_cypherConsoleCommandParameter)
-  try {
-    this.state = 461
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 8, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 451
-        this.url()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 452
-        this.json()
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 453
-        this.arrowExpression()
-        break
-
-      case 4:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 454
-        this.mapLiteral()
-        break
-
-      case 5:
-        this.enterOuterAlt(localctx, 5)
-        this.state = 455
-        this.keyValueLiteral()
-        break
-
-      case 6:
-        this.enterOuterAlt(localctx, 6)
-        this.state = 456
-        this.stringLiteral()
-        break
-
-      case 7:
-        this.enterOuterAlt(localctx, 7)
-        this.state = 457
-        this.numberLiteral()
-        break
-
-      case 8:
-        this.enterOuterAlt(localctx, 8)
-        this.state = 458
-        this.booleanLiteral()
-        break
-
-      case 9:
-        this.enterOuterAlt(localctx, 9)
-        this.state = 459
-        this.subCommand()
-        break
-
-      case 10:
-        this.enterOuterAlt(localctx, 10)
-        this.state = 460
-        this.commandPath()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ArrowExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_arrowExpression
-  return this
-}
-
-ArrowExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ArrowExpressionContext.prototype.constructor = ArrowExpressionContext
-
-ArrowExpressionContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-ArrowExpressionContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-ArrowExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ArrowExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterArrowExpression(this)
-  }
-}
-
-ArrowExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitArrowExpression(this)
-  }
-}
-
-CypherParser.ArrowExpressionContext = ArrowExpressionContext
-
-CypherParser.prototype.arrowExpression = function() {
-  var localctx = new ArrowExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 12, CypherParser.RULE_arrowExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 463
-    this.symbolicName()
-    this.state = 465
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 464
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 467
-    this.match(CypherParser.T__3)
-    this.state = 469
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 468
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 471
-    this.expression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UrlContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_url
-  return this
-}
-
-UrlContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-UrlContext.prototype.constructor = UrlContext
-
-UrlContext.prototype.uri = function() {
-  return this.getTypedRuleContext(UriContext, 0)
-}
-
-UrlContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUrl(this)
-  }
-}
-
-UrlContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUrl(this)
-  }
-}
-
-CypherParser.UrlContext = UrlContext
-
-CypherParser.prototype.url = function() {
-  var localctx = new UrlContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 14, CypherParser.RULE_url)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 473
-    this.uri()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UriContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_uri
-  return this
-}
-
-UriContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-UriContext.prototype.constructor = UriContext
-
-UriContext.prototype.scheme = function() {
-  return this.getTypedRuleContext(SchemeContext, 0)
-}
-
-UriContext.prototype.host = function() {
-  return this.getTypedRuleContext(HostContext, 0)
-}
-
-UriContext.prototype.login = function() {
-  return this.getTypedRuleContext(LoginContext, 0)
-}
-
-UriContext.prototype.port = function() {
-  return this.getTypedRuleContext(PortContext, 0)
-}
-
-UriContext.prototype.path = function() {
-  return this.getTypedRuleContext(PathContext, 0)
-}
-
-UriContext.prototype.urlQuery = function() {
-  return this.getTypedRuleContext(UrlQueryContext, 0)
-}
-
-UriContext.prototype.frag = function() {
-  return this.getTypedRuleContext(FragContext, 0)
-}
-
-UriContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUri(this)
-  }
-}
-
-UriContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUri(this)
-  }
-}
-
-CypherParser.UriContext = UriContext
-
-CypherParser.prototype.uri = function() {
-  var localctx = new UriContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 16, CypherParser.RULE_uri)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 475
-    this.scheme()
-    this.state = 476
-    this.match(CypherParser.T__4)
-    this.state = 478
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 11, this._ctx)
-    if (la_ === 1) {
-      this.state = 477
-      this.login()
-    }
-    this.state = 480
-    this.host()
-    this.state = 483
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__1) {
-      this.state = 481
-      this.match(CypherParser.T__1)
-      this.state = 482
-      this.port()
-    }
-
-    this.state = 487
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__5) {
-      this.state = 485
-      this.match(CypherParser.T__5)
-      this.state = 486
-      this.path()
-    }
-
-    this.state = 490
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__9) {
-      this.state = 489
-      this.urlQuery()
-    }
-
-    this.state = 493
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__8) {
-      this.state = 492
-      this.frag()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SchemeContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_scheme
-  return this
-}
-
-SchemeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SchemeContext.prototype.constructor = SchemeContext
-
-SchemeContext.prototype.string = function() {
-  return this.getTypedRuleContext(StringContext, 0)
-}
-
-SchemeContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterScheme(this)
-  }
-}
-
-SchemeContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitScheme(this)
-  }
-}
-
-CypherParser.SchemeContext = SchemeContext
-
-CypherParser.prototype.scheme = function() {
-  var localctx = new SchemeContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 18, CypherParser.RULE_scheme)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 495
-    this.string()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function HostContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_host
-  return this
-}
-
-HostContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-HostContext.prototype.constructor = HostContext
-
-HostContext.prototype.hostname = function() {
-  return this.getTypedRuleContext(HostnameContext, 0)
-}
-
-HostContext.prototype.hostnumber = function() {
-  return this.getTypedRuleContext(HostnumberContext, 0)
-}
-
-HostContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterHost(this)
-  }
-}
-
-HostContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitHost(this)
-  }
-}
-
-CypherParser.HostContext = HostContext
-
-CypherParser.prototype.host = function() {
-  var localctx = new HostContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 20, CypherParser.RULE_host)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 498
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__5) {
-      this.state = 497
-      this.match(CypherParser.T__5)
-    }
-
-    this.state = 502
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.CYPHER:
-      case CypherParser.EXPLAIN:
-      case CypherParser.PROFILE:
-      case CypherParser.USING:
-      case CypherParser.PERIODIC:
-      case CypherParser.COMMIT:
-      case CypherParser.UNION:
-      case CypherParser.ALL:
-      case CypherParser.CREATE:
-      case CypherParser.DROP:
-      case CypherParser.INDEX:
-      case CypherParser.ON:
-      case CypherParser.CONSTRAINT:
-      case CypherParser.ASSERT:
-      case CypherParser.IS:
-      case CypherParser.UNIQUE:
-      case CypherParser.EXISTS:
-      case CypherParser.LOAD:
-      case CypherParser.CSV:
-      case CypherParser.WITH:
-      case CypherParser.HEADERS:
-      case CypherParser.FROM:
-      case CypherParser.AS:
-      case CypherParser.FIELDTERMINATOR:
-      case CypherParser.OPTIONAL:
-      case CypherParser.MATCH:
-      case CypherParser.UNWIND:
-      case CypherParser.MERGE:
-      case CypherParser.SET:
-      case CypherParser.DETACH:
-      case CypherParser.DELETE:
-      case CypherParser.REMOVE:
-      case CypherParser.FOREACH:
-      case CypherParser.IN:
-      case CypherParser.DISTINCT:
-      case CypherParser.RETURN:
-      case CypherParser.ORDER:
-      case CypherParser.BY:
-      case CypherParser.L_SKIP:
-      case CypherParser.LIMIT:
-      case CypherParser.ASCENDING:
-      case CypherParser.ASC:
-      case CypherParser.DESCENDING:
-      case CypherParser.DESC:
-      case CypherParser.JOIN:
-      case CypherParser.SCAN:
-      case CypherParser.START:
-      case CypherParser.NODE:
-      case CypherParser.RELATIONSHIP:
-      case CypherParser.REL:
-      case CypherParser.WHERE:
-      case CypherParser.SHORTESTPATH:
-      case CypherParser.ALLSHORTESTPATHS:
-      case CypherParser.OR:
-      case CypherParser.XOR:
-      case CypherParser.AND:
-      case CypherParser.NOT:
-      case CypherParser.STARTS:
-      case CypherParser.ENDS:
-      case CypherParser.CONTAINS:
-      case CypherParser.NULL:
-      case CypherParser.COUNT:
-      case CypherParser.FILTER:
-      case CypherParser.EXTRACT:
-      case CypherParser.ANY:
-      case CypherParser.NONE:
-      case CypherParser.SINGLE:
-      case CypherParser.TRUE:
-      case CypherParser.FALSE:
-      case CypherParser.REDUCE:
-      case CypherParser.CASE:
-      case CypherParser.ELSE:
-      case CypherParser.END:
-      case CypherParser.WHEN:
-      case CypherParser.THEN:
-      case CypherParser.CALL:
-      case CypherParser.YIELD:
-      case CypherParser.KEY:
-      case CypherParser.HexLetter:
-      case CypherParser.UnescapedSymbolicName:
-      case CypherParser.EscapedSymbolicName:
-        this.state = 500
-        this.hostname()
-        break
-      case CypherParser.HexInteger:
-      case CypherParser.DecimalInteger:
-      case CypherParser.OctalInteger:
-        this.state = 501
-        this.hostnumber()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function HostnameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_hostname
-  return this
-}
-
-HostnameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-HostnameContext.prototype.constructor = HostnameContext
-
-HostnameContext.prototype.string = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(StringContext)
-  } else {
-    return this.getTypedRuleContext(StringContext, i)
-  }
-}
-
-HostnameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterHostname(this)
-  }
-}
-
-HostnameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitHostname(this)
-  }
-}
-
-CypherParser.HostnameContext = HostnameContext
-
-CypherParser.prototype.hostname = function() {
-  var localctx = new HostnameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 22, CypherParser.RULE_hostname)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 504
-    this.string()
-    this.state = 509
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (_la === CypherParser.T__6) {
-      this.state = 505
-      this.match(CypherParser.T__6)
-      this.state = 506
-      this.string()
-      this.state = 511
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function HostnumberContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_hostnumber
-  return this
-}
-
-HostnumberContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-HostnumberContext.prototype.constructor = HostnumberContext
-
-HostnumberContext.prototype.urlDigits = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(UrlDigitsContext)
-  } else {
-    return this.getTypedRuleContext(UrlDigitsContext, i)
-  }
-}
-
-HostnumberContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterHostnumber(this)
-  }
-}
-
-HostnumberContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitHostnumber(this)
-  }
-}
-
-CypherParser.HostnumberContext = HostnumberContext
-
-CypherParser.prototype.hostnumber = function() {
-  var localctx = new HostnumberContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 24, CypherParser.RULE_hostnumber)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 512
-    this.urlDigits()
-    this.state = 513
-    this.match(CypherParser.T__6)
-    this.state = 514
-    this.urlDigits()
-    this.state = 515
-    this.match(CypherParser.T__6)
-    this.state = 516
-    this.urlDigits()
-    this.state = 517
-    this.match(CypherParser.T__6)
-    this.state = 518
-    this.urlDigits()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PortContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_port
-  return this
-}
-
-PortContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-PortContext.prototype.constructor = PortContext
-
-PortContext.prototype.urlDigits = function() {
-  return this.getTypedRuleContext(UrlDigitsContext, 0)
-}
-
-PortContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPort(this)
-  }
-}
-
-PortContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPort(this)
-  }
-}
-
-CypherParser.PortContext = PortContext
-
-CypherParser.prototype.port = function() {
-  var localctx = new PortContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 26, CypherParser.RULE_port)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 520
-    this.urlDigits()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PathContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_path
-  return this
-}
-
-PathContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-PathContext.prototype.constructor = PathContext
-
-PathContext.prototype.string = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(StringContext)
-  } else {
-    return this.getTypedRuleContext(StringContext, i)
-  }
-}
-
-PathContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPath(this)
-  }
-}
-
-PathContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPath(this)
-  }
-}
-
-CypherParser.PathContext = PathContext
-
-CypherParser.prototype.path = function() {
-  var localctx = new PathContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 28, CypherParser.RULE_path)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 522
-    this.string()
-    this.state = 527
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (_la === CypherParser.T__5) {
-      this.state = 523
-      this.match(CypherParser.T__5)
-      this.state = 524
-      this.string()
-      this.state = 529
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UserContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_user
-  return this
-}
-
-UserContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-UserContext.prototype.constructor = UserContext
-
-UserContext.prototype.string = function() {
-  return this.getTypedRuleContext(StringContext, 0)
-}
-
-UserContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUser(this)
-  }
-}
-
-UserContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUser(this)
-  }
-}
-
-CypherParser.UserContext = UserContext
-
-CypherParser.prototype.user = function() {
-  var localctx = new UserContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 30, CypherParser.RULE_user)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 530
-    this.string()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LoginContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_login
-  return this
-}
-
-LoginContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-LoginContext.prototype.constructor = LoginContext
-
-LoginContext.prototype.user = function() {
-  return this.getTypedRuleContext(UserContext, 0)
-}
-
-LoginContext.prototype.password = function() {
-  return this.getTypedRuleContext(PasswordContext, 0)
-}
-
-LoginContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLogin(this)
-  }
-}
-
-LoginContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLogin(this)
-  }
-}
-
-CypherParser.LoginContext = LoginContext
-
-CypherParser.prototype.login = function() {
-  var localctx = new LoginContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 32, CypherParser.RULE_login)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 532
-    this.user()
-    this.state = 533
-    this.match(CypherParser.T__1)
-    this.state = 534
-    this.password()
-    this.state = 535
-    this.match(CypherParser.T__7)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PasswordContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_password
-  return this
-}
-
-PasswordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-PasswordContext.prototype.constructor = PasswordContext
-
-PasswordContext.prototype.string = function() {
-  return this.getTypedRuleContext(StringContext, 0)
-}
-
-PasswordContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPassword(this)
-  }
-}
-
-PasswordContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPassword(this)
-  }
-}
-
-CypherParser.PasswordContext = PasswordContext
-
-CypherParser.prototype.password = function() {
-  var localctx = new PasswordContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 34, CypherParser.RULE_password)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 537
-    this.string()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function FragContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_frag
-  return this
-}
-
-FragContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-FragContext.prototype.constructor = FragContext
-
-FragContext.prototype.string = function() {
-  return this.getTypedRuleContext(StringContext, 0)
-}
-
-FragContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterFrag(this)
-  }
-}
-
-FragContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitFrag(this)
-  }
-}
-
-CypherParser.FragContext = FragContext
-
-CypherParser.prototype.frag = function() {
-  var localctx = new FragContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 36, CypherParser.RULE_frag)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 539
-    this.match(CypherParser.T__8)
-    this.state = 540
-    this.string()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UrlQueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_urlQuery
-  return this
-}
-
-UrlQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-UrlQueryContext.prototype.constructor = UrlQueryContext
-
-UrlQueryContext.prototype.search = function() {
-  return this.getTypedRuleContext(SearchContext, 0)
-}
-
-UrlQueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUrlQuery(this)
-  }
-}
-
-UrlQueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUrlQuery(this)
-  }
-}
-
-CypherParser.UrlQueryContext = UrlQueryContext
-
-CypherParser.prototype.urlQuery = function() {
-  var localctx = new UrlQueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 38, CypherParser.RULE_urlQuery)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 542
-    this.match(CypherParser.T__9)
-    this.state = 543
-    this.search()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SearchContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_search
-  return this
-}
-
-SearchContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SearchContext.prototype.constructor = SearchContext
-
-SearchContext.prototype.searchparameter = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SearchparameterContext)
-  } else {
-    return this.getTypedRuleContext(SearchparameterContext, i)
-  }
-}
-
-SearchContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSearch(this)
-  }
-}
-
-SearchContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSearch(this)
-  }
-}
-
-CypherParser.SearchContext = SearchContext
-
-CypherParser.prototype.search = function() {
-  var localctx = new SearchContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 40, CypherParser.RULE_search)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 545
-    this.searchparameter()
-    this.state = 550
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (_la === CypherParser.T__10) {
-      this.state = 546
-      this.match(CypherParser.T__10)
-      this.state = 547
-      this.searchparameter()
-      this.state = 552
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SearchparameterContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_searchparameter
-  return this
-}
-
-SearchparameterContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-SearchparameterContext.prototype.constructor = SearchparameterContext
-
-SearchparameterContext.prototype.string = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(StringContext)
-  } else {
-    return this.getTypedRuleContext(StringContext, i)
-  }
-}
-
-SearchparameterContext.prototype.urlDigits = function() {
-  return this.getTypedRuleContext(UrlDigitsContext, 0)
-}
-
-SearchparameterContext.prototype.UrlHex = function() {
-  return this.getToken(CypherParser.UrlHex, 0)
-}
-
-SearchparameterContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSearchparameter(this)
-  }
-}
-
-SearchparameterContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSearchparameter(this)
-  }
-}
-
-CypherParser.SearchparameterContext = SearchparameterContext
-
-CypherParser.prototype.searchparameter = function() {
-  var localctx = new SearchparameterContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 42, CypherParser.RULE_searchparameter)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 553
-    this.string()
-    this.state = 560
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__11) {
-      this.state = 554
-      this.match(CypherParser.T__11)
-      this.state = 558
-      this._errHandler.sync(this)
-      switch (this._input.LA(1)) {
-        case CypherParser.CYPHER:
-        case CypherParser.EXPLAIN:
-        case CypherParser.PROFILE:
-        case CypherParser.USING:
-        case CypherParser.PERIODIC:
-        case CypherParser.COMMIT:
-        case CypherParser.UNION:
-        case CypherParser.ALL:
-        case CypherParser.CREATE:
-        case CypherParser.DROP:
-        case CypherParser.INDEX:
-        case CypherParser.ON:
-        case CypherParser.CONSTRAINT:
-        case CypherParser.ASSERT:
-        case CypherParser.IS:
-        case CypherParser.UNIQUE:
-        case CypherParser.EXISTS:
-        case CypherParser.LOAD:
-        case CypherParser.CSV:
-        case CypherParser.WITH:
-        case CypherParser.HEADERS:
-        case CypherParser.FROM:
-        case CypherParser.AS:
-        case CypherParser.FIELDTERMINATOR:
-        case CypherParser.OPTIONAL:
-        case CypherParser.MATCH:
-        case CypherParser.UNWIND:
-        case CypherParser.MERGE:
-        case CypherParser.SET:
-        case CypherParser.DETACH:
-        case CypherParser.DELETE:
-        case CypherParser.REMOVE:
-        case CypherParser.FOREACH:
-        case CypherParser.IN:
-        case CypherParser.DISTINCT:
-        case CypherParser.RETURN:
-        case CypherParser.ORDER:
-        case CypherParser.BY:
-        case CypherParser.L_SKIP:
-        case CypherParser.LIMIT:
-        case CypherParser.ASCENDING:
-        case CypherParser.ASC:
-        case CypherParser.DESCENDING:
-        case CypherParser.DESC:
-        case CypherParser.JOIN:
-        case CypherParser.SCAN:
-        case CypherParser.START:
-        case CypherParser.NODE:
-        case CypherParser.RELATIONSHIP:
-        case CypherParser.REL:
-        case CypherParser.WHERE:
-        case CypherParser.SHORTESTPATH:
-        case CypherParser.ALLSHORTESTPATHS:
-        case CypherParser.OR:
-        case CypherParser.XOR:
-        case CypherParser.AND:
-        case CypherParser.NOT:
-        case CypherParser.STARTS:
-        case CypherParser.ENDS:
-        case CypherParser.CONTAINS:
-        case CypherParser.NULL:
-        case CypherParser.COUNT:
-        case CypherParser.FILTER:
-        case CypherParser.EXTRACT:
-        case CypherParser.ANY:
-        case CypherParser.NONE:
-        case CypherParser.SINGLE:
-        case CypherParser.TRUE:
-        case CypherParser.FALSE:
-        case CypherParser.REDUCE:
-        case CypherParser.CASE:
-        case CypherParser.ELSE:
-        case CypherParser.END:
-        case CypherParser.WHEN:
-        case CypherParser.THEN:
-        case CypherParser.CALL:
-        case CypherParser.YIELD:
-        case CypherParser.KEY:
-        case CypherParser.HexLetter:
-        case CypherParser.UnescapedSymbolicName:
-        case CypherParser.EscapedSymbolicName:
-          this.state = 555
-          this.string()
-          break
-        case CypherParser.HexInteger:
-        case CypherParser.DecimalInteger:
-        case CypherParser.OctalInteger:
-          this.state = 556
-          this.urlDigits()
-          break
-        case CypherParser.UrlHex:
-          this.state = 557
-          this.match(CypherParser.UrlHex)
-          break
-        default:
-          throw new antlr4.error.NoViableAltException(this)
-      }
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function StringContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_string
-  return this
-}
-
-StringContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-StringContext.prototype.constructor = StringContext
-
-StringContext.prototype.symbolicName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SymbolicNameContext)
-  } else {
-    return this.getTypedRuleContext(SymbolicNameContext, i)
-  }
-}
-
-StringContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterString(this)
-  }
-}
-
-StringContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitString(this)
-  }
-}
-
-CypherParser.StringContext = StringContext
-
-CypherParser.prototype.string = function() {
-  var localctx = new StringContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 44, CypherParser.RULE_string)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 562
-    this.symbolicName()
-    this.state = 569
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 24, this._ctx)
-    while (_alt != 1 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1 + 1) {
-        this.state = 564
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.T__6 || _la === CypherParser.T__12) {
-          this.state = 563
-          _la = this._input.LA(1)
-          if (!(_la === CypherParser.T__6 || _la === CypherParser.T__12)) {
-            this._errHandler.recoverInline(this)
-          } else {
-            this._errHandler.reportMatch(this)
-            this.consume()
-          }
-        }
-
-        this.state = 566
-        this.symbolicName()
-      }
-      this.state = 571
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 24, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UrlDigitsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_urlDigits
-  return this
-}
-
-UrlDigitsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-UrlDigitsContext.prototype.constructor = UrlDigitsContext
-
-UrlDigitsContext.prototype.integerLiteral = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(IntegerLiteralContext)
-  } else {
-    return this.getTypedRuleContext(IntegerLiteralContext, i)
-  }
-}
-
-UrlDigitsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUrlDigits(this)
-  }
-}
-
-UrlDigitsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUrlDigits(this)
-  }
-}
-
-CypherParser.UrlDigitsContext = UrlDigitsContext
-
-CypherParser.prototype.urlDigits = function() {
-  var localctx = new UrlDigitsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 46, CypherParser.RULE_urlDigits)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 573
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    do {
-      this.state = 572
-      this.integerLiteral()
-      this.state = 575
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    } while (
-      ((_la - 135) & ~0x1f) == 0 &&
-      ((1 << (_la - 135)) &
-        ((1 << (CypherParser.HexInteger - 135)) |
-          (1 << (CypherParser.DecimalInteger - 135)) |
-          (1 << (CypherParser.OctalInteger - 135)))) !==
-        0
-    )
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function JsonContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_json
-  return this
-}
-
-JsonContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-JsonContext.prototype.constructor = JsonContext
-
-JsonContext.prototype.value = function() {
-  return this.getTypedRuleContext(ValueContext, 0)
-}
-
-JsonContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterJson(this)
-  }
-}
-
-JsonContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitJson(this)
-  }
-}
-
-CypherParser.JsonContext = JsonContext
-
-CypherParser.prototype.json = function() {
-  var localctx = new JsonContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 48, CypherParser.RULE_json)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 577
-    this.value()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ObjContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_obj
-  return this
-}
-
-ObjContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ObjContext.prototype.constructor = ObjContext
-
-ObjContext.prototype.pair = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PairContext)
-  } else {
-    return this.getTypedRuleContext(PairContext, i)
-  }
-}
-
-ObjContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ObjContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterObj(this)
-  }
-}
-
-ObjContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitObj(this)
-  }
-}
-
-CypherParser.ObjContext = ObjContext
-
-CypherParser.prototype.obj = function() {
-  var localctx = new ObjContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 50, CypherParser.RULE_obj)
-  var _la = 0 // Token type
-  try {
-    this.state = 607
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 32, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 579
-        this.match(CypherParser.T__13)
-        this.state = 581
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 580
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 583
-        this.pair()
-        this.state = 585
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 584
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 597
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        while (_la === CypherParser.T__14) {
-          this.state = 587
-          this.match(CypherParser.T__14)
-          this.state = 589
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-          if (_la === CypherParser.SP) {
-            this.state = 588
-            this.match(CypherParser.SP)
-          }
-
-          this.state = 591
-          this.pair()
-          this.state = 593
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-          if (_la === CypherParser.SP) {
-            this.state = 592
-            this.match(CypherParser.SP)
-          }
-
-          this.state = 599
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-        }
-        this.state = 600
-        this.match(CypherParser.T__15)
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 602
-        this.match(CypherParser.T__13)
-        this.state = 604
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 603
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 606
-        this.match(CypherParser.T__15)
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PairContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_pair
-  return this
-}
-
-PairContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-PairContext.prototype.constructor = PairContext
-
-PairContext.prototype.stringLiteral = function() {
-  return this.getTypedRuleContext(StringLiteralContext, 0)
-}
-
-PairContext.prototype.value = function() {
-  return this.getTypedRuleContext(ValueContext, 0)
-}
-
-PairContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PairContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPair(this)
-  }
-}
-
-PairContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPair(this)
-  }
-}
-
-CypherParser.PairContext = PairContext
-
-CypherParser.prototype.pair = function() {
-  var localctx = new PairContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 52, CypherParser.RULE_pair)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 609
-    this.stringLiteral()
-    this.state = 611
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 610
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 613
-    this.match(CypherParser.T__1)
-    this.state = 615
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 614
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 617
-    this.value()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ArrayContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_array
-  return this
-}
-
-ArrayContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ArrayContext.prototype.constructor = ArrayContext
-
-ArrayContext.prototype.value = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ValueContext)
-  } else {
-    return this.getTypedRuleContext(ValueContext, i)
-  }
-}
-
-ArrayContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ArrayContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterArray(this)
-  }
-}
-
-ArrayContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitArray(this)
-  }
-}
-
-CypherParser.ArrayContext = ArrayContext
-
-CypherParser.prototype.array = function() {
-  var localctx = new ArrayContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 54, CypherParser.RULE_array)
-  var _la = 0 // Token type
-  try {
-    this.state = 647
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 41, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 619
-        this.match(CypherParser.T__16)
-        this.state = 621
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 620
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 623
-        this.value()
-        this.state = 625
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 624
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 637
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        while (_la === CypherParser.T__14) {
-          this.state = 627
-          this.match(CypherParser.T__14)
-          this.state = 629
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-          if (_la === CypherParser.SP) {
-            this.state = 628
-            this.match(CypherParser.SP)
-          }
-
-          this.state = 631
-          this.value()
-          this.state = 633
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-          if (_la === CypherParser.SP) {
-            this.state = 632
-            this.match(CypherParser.SP)
-          }
-
-          this.state = 639
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-        }
-        this.state = 640
-        this.match(CypherParser.T__17)
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 642
-        this.match(CypherParser.T__16)
-        this.state = 644
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 643
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 646
-        this.match(CypherParser.T__17)
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ValueContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_value
-  return this
-}
-
-ValueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ValueContext.prototype.constructor = ValueContext
-
-ValueContext.prototype.stringLiteral = function() {
-  return this.getTypedRuleContext(StringLiteralContext, 0)
-}
-
-ValueContext.prototype.numberLiteral = function() {
-  return this.getTypedRuleContext(NumberLiteralContext, 0)
-}
-
-ValueContext.prototype.obj = function() {
-  return this.getTypedRuleContext(ObjContext, 0)
-}
-
-ValueContext.prototype.array = function() {
-  return this.getTypedRuleContext(ArrayContext, 0)
-}
-
-ValueContext.prototype.booleanLiteral = function() {
-  return this.getTypedRuleContext(BooleanLiteralContext, 0)
-}
-
-ValueContext.prototype.NULL = function() {
-  return this.getToken(CypherParser.NULL, 0)
-}
-
-ValueContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterValue(this)
-  }
-}
-
-ValueContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitValue(this)
-  }
-}
-
-CypherParser.ValueContext = ValueContext
-
-CypherParser.prototype.value = function() {
-  var localctx = new ValueContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 56, CypherParser.RULE_value)
-  try {
-    this.state = 655
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.StringLiteral:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 649
-        this.stringLiteral()
-        break
-      case CypherParser.HexInteger:
-      case CypherParser.DecimalInteger:
-      case CypherParser.OctalInteger:
-      case CypherParser.ExponentDecimalReal:
-      case CypherParser.RegularDecimalReal:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 650
-        this.numberLiteral()
-        break
-      case CypherParser.T__13:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 651
-        this.obj()
-        break
-      case CypherParser.T__16:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 652
-        this.array()
-        break
-      case CypherParser.TRUE:
-      case CypherParser.FALSE:
-        this.enterOuterAlt(localctx, 5)
-        this.state = 653
-        this.booleanLiteral()
-        break
-      case CypherParser.NULL:
-        this.enterOuterAlt(localctx, 6)
-        this.state = 654
-        this.match(CypherParser.NULL)
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function KeyValueLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_keyValueLiteral
-  return this
-}
-
-KeyValueLiteralContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-KeyValueLiteralContext.prototype.constructor = KeyValueLiteralContext
-
-KeyValueLiteralContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-KeyValueLiteralContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-KeyValueLiteralContext.prototype.StringLiteral = function() {
-  return this.getToken(CypherParser.StringLiteral, 0)
-}
-
-KeyValueLiteralContext.prototype.numberLiteral = function() {
-  return this.getTypedRuleContext(NumberLiteralContext, 0)
-}
-
-KeyValueLiteralContext.prototype.booleanLiteral = function() {
-  return this.getTypedRuleContext(BooleanLiteralContext, 0)
-}
-
-KeyValueLiteralContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-KeyValueLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterKeyValueLiteral(this)
-  }
-}
-
-KeyValueLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitKeyValueLiteral(this)
-  }
-}
-
-CypherParser.KeyValueLiteralContext = KeyValueLiteralContext
-
-CypherParser.prototype.keyValueLiteral = function() {
-  var localctx = new KeyValueLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 58, CypherParser.RULE_keyValueLiteral)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 657
-    this.variable()
-    this.state = 658
-    this.match(CypherParser.T__1)
-    this.state = 659
-    this.match(CypherParser.SP)
-    this.state = 664
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 43, this._ctx)
-    switch (la_) {
-      case 1:
-        this.state = 660
-        this.match(CypherParser.StringLiteral)
-        break
-
-      case 2:
-        this.state = 661
-        this.numberLiteral()
-        break
-
-      case 3:
-        this.state = 662
-        this.booleanLiteral()
-        break
-
-      case 4:
-        this.state = 663
-        this.symbolicName()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CommandPathContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_commandPath
-  return this
-}
-
-CommandPathContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-CommandPathContext.prototype.constructor = CommandPathContext
-
-CommandPathContext.prototype.symbolicName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SymbolicNameContext)
-  } else {
-    return this.getTypedRuleContext(SymbolicNameContext, i)
-  }
-}
-
-CommandPathContext.prototype.numberLiteral = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(NumberLiteralContext)
-  } else {
-    return this.getTypedRuleContext(NumberLiteralContext, i)
-  }
-}
-
-CommandPathContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCommandPath(this)
-  }
-}
-
-CommandPathContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCommandPath(this)
-  }
-}
-
-CypherParser.CommandPathContext = CommandPathContext
-
-CypherParser.prototype.commandPath = function() {
-  var localctx = new CommandPathContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 60, CypherParser.RULE_commandPath)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 671
-    this._errHandler.sync(this)
-    var _alt = 1
-    do {
-      switch (_alt) {
-        case 1:
-          this.state = 666
-          this.match(CypherParser.T__5)
-          this.state = 669
-          this._errHandler.sync(this)
-          switch (this._input.LA(1)) {
-            case CypherParser.CYPHER:
-            case CypherParser.EXPLAIN:
-            case CypherParser.PROFILE:
-            case CypherParser.USING:
-            case CypherParser.PERIODIC:
-            case CypherParser.COMMIT:
-            case CypherParser.UNION:
-            case CypherParser.ALL:
-            case CypherParser.CREATE:
-            case CypherParser.DROP:
-            case CypherParser.INDEX:
-            case CypherParser.ON:
-            case CypherParser.CONSTRAINT:
-            case CypherParser.ASSERT:
-            case CypherParser.IS:
-            case CypherParser.UNIQUE:
-            case CypherParser.EXISTS:
-            case CypherParser.LOAD:
-            case CypherParser.CSV:
-            case CypherParser.WITH:
-            case CypherParser.HEADERS:
-            case CypherParser.FROM:
-            case CypherParser.AS:
-            case CypherParser.FIELDTERMINATOR:
-            case CypherParser.OPTIONAL:
-            case CypherParser.MATCH:
-            case CypherParser.UNWIND:
-            case CypherParser.MERGE:
-            case CypherParser.SET:
-            case CypherParser.DETACH:
-            case CypherParser.DELETE:
-            case CypherParser.REMOVE:
-            case CypherParser.FOREACH:
-            case CypherParser.IN:
-            case CypherParser.DISTINCT:
-            case CypherParser.RETURN:
-            case CypherParser.ORDER:
-            case CypherParser.BY:
-            case CypherParser.L_SKIP:
-            case CypherParser.LIMIT:
-            case CypherParser.ASCENDING:
-            case CypherParser.ASC:
-            case CypherParser.DESCENDING:
-            case CypherParser.DESC:
-            case CypherParser.JOIN:
-            case CypherParser.SCAN:
-            case CypherParser.START:
-            case CypherParser.NODE:
-            case CypherParser.RELATIONSHIP:
-            case CypherParser.REL:
-            case CypherParser.WHERE:
-            case CypherParser.SHORTESTPATH:
-            case CypherParser.ALLSHORTESTPATHS:
-            case CypherParser.OR:
-            case CypherParser.XOR:
-            case CypherParser.AND:
-            case CypherParser.NOT:
-            case CypherParser.STARTS:
-            case CypherParser.ENDS:
-            case CypherParser.CONTAINS:
-            case CypherParser.NULL:
-            case CypherParser.COUNT:
-            case CypherParser.FILTER:
-            case CypherParser.EXTRACT:
-            case CypherParser.ANY:
-            case CypherParser.NONE:
-            case CypherParser.SINGLE:
-            case CypherParser.TRUE:
-            case CypherParser.FALSE:
-            case CypherParser.REDUCE:
-            case CypherParser.CASE:
-            case CypherParser.ELSE:
-            case CypherParser.END:
-            case CypherParser.WHEN:
-            case CypherParser.THEN:
-            case CypherParser.CALL:
-            case CypherParser.YIELD:
-            case CypherParser.KEY:
-            case CypherParser.HexLetter:
-            case CypherParser.UnescapedSymbolicName:
-            case CypherParser.EscapedSymbolicName:
-              this.state = 667
-              this.symbolicName()
-              break
-            case CypherParser.HexInteger:
-            case CypherParser.DecimalInteger:
-            case CypherParser.OctalInteger:
-            case CypherParser.ExponentDecimalReal:
-            case CypherParser.RegularDecimalReal:
-              this.state = 668
-              this.numberLiteral()
-              break
-            default:
-              throw new antlr4.error.NoViableAltException(this)
-          }
-          break
-        default:
-          throw new antlr4.error.NoViableAltException(this)
-      }
-      this.state = 673
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 45, this._ctx)
-    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
-    this.state = 676
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__5) {
-      this.state = 675
-      this.match(CypherParser.T__5)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SubCommandContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_subCommand
-  return this
-}
-
-SubCommandContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SubCommandContext.prototype.constructor = SubCommandContext
-
-SubCommandContext.prototype.symbolicName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SymbolicNameContext)
-  } else {
-    return this.getTypedRuleContext(SymbolicNameContext, i)
-  }
-}
-
-SubCommandContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSubCommand(this)
-  }
-}
-
-SubCommandContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSubCommand(this)
-  }
-}
-
-CypherParser.SubCommandContext = SubCommandContext
-
-CypherParser.prototype.subCommand = function() {
-  var localctx = new SubCommandContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 62, CypherParser.RULE_subCommand)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 678
-    this.symbolicName()
-    this.state = 683
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (_la === CypherParser.T__2) {
-      this.state = 679
-      this.match(CypherParser.T__2)
-      this.state = 680
-      this.symbolicName()
-      this.state = 685
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CypherQueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypherQuery
-  return this
-}
-
-CypherQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-CypherQueryContext.prototype.constructor = CypherQueryContext
-
-CypherQueryContext.prototype.queryOptions = function() {
-  return this.getTypedRuleContext(QueryOptionsContext, 0)
-}
-
-CypherQueryContext.prototype.statement = function() {
-  return this.getTypedRuleContext(StatementContext, 0)
-}
-
-CypherQueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypherQuery(this)
-  }
-}
-
-CypherQueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypherQuery(this)
-  }
-}
-
-CypherParser.CypherQueryContext = CypherQueryContext
-
-CypherParser.prototype.cypherQuery = function() {
-  var localctx = new CypherQueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 64, CypherParser.RULE_cypherQuery)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 686
-    this.queryOptions()
-    this.state = 687
-    this.statement()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function QueryOptionsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_queryOptions
-  return this
-}
-
-QueryOptionsContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-QueryOptionsContext.prototype.constructor = QueryOptionsContext
-
-QueryOptionsContext.prototype.anyCypherOption = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(AnyCypherOptionContext)
-  } else {
-    return this.getTypedRuleContext(AnyCypherOptionContext, i)
-  }
-}
-
-QueryOptionsContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-QueryOptionsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterQueryOptions(this)
-  }
-}
-
-QueryOptionsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitQueryOptions(this)
-  }
-}
-
-CypherParser.QueryOptionsContext = QueryOptionsContext
-
-CypherParser.prototype.queryOptions = function() {
-  var localctx = new QueryOptionsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 66, CypherParser.RULE_queryOptions)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 695
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (
-      ((_la - 54) & ~0x1f) == 0 &&
-      ((1 << (_la - 54)) &
-        ((1 << (CypherParser.CYPHER - 54)) |
-          (1 << (CypherParser.EXPLAIN - 54)) |
-          (1 << (CypherParser.PROFILE - 54)))) !==
-        0
-    ) {
-      this.state = 689
-      this.anyCypherOption()
-      this.state = 691
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 690
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 697
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AnyCypherOptionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_anyCypherOption
-  return this
-}
-
-AnyCypherOptionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AnyCypherOptionContext.prototype.constructor = AnyCypherOptionContext
-
-AnyCypherOptionContext.prototype.cypherOption = function() {
-  return this.getTypedRuleContext(CypherOptionContext, 0)
-}
-
-AnyCypherOptionContext.prototype.explain = function() {
-  return this.getTypedRuleContext(ExplainContext, 0)
-}
-
-AnyCypherOptionContext.prototype.profile = function() {
-  return this.getTypedRuleContext(ProfileContext, 0)
-}
-
-AnyCypherOptionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAnyCypherOption(this)
-  }
-}
-
-AnyCypherOptionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAnyCypherOption(this)
-  }
-}
-
-CypherParser.AnyCypherOptionContext = AnyCypherOptionContext
-
-CypherParser.prototype.anyCypherOption = function() {
-  var localctx = new AnyCypherOptionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 68, CypherParser.RULE_anyCypherOption)
-  try {
-    this.state = 701
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.CYPHER:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 698
-        this.cypherOption()
-        break
-      case CypherParser.EXPLAIN:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 699
-        this.explain()
-        break
-      case CypherParser.PROFILE:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 700
-        this.profile()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CypherOptionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_cypherOption
-  return this
-}
-
-CypherOptionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CypherOptionContext.prototype.constructor = CypherOptionContext
-
-CypherOptionContext.prototype.CYPHER = function() {
-  return this.getToken(CypherParser.CYPHER, 0)
-}
-
-CypherOptionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-CypherOptionContext.prototype.versionNumber = function() {
-  return this.getTypedRuleContext(VersionNumberContext, 0)
-}
-
-CypherOptionContext.prototype.configurationOption = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ConfigurationOptionContext)
-  } else {
-    return this.getTypedRuleContext(ConfigurationOptionContext, i)
-  }
-}
-
-CypherOptionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCypherOption(this)
-  }
-}
-
-CypherOptionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCypherOption(this)
-  }
-}
-
-CypherParser.CypherOptionContext = CypherOptionContext
-
-CypherParser.prototype.cypherOption = function() {
-  var localctx = new CypherOptionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 70, CypherParser.RULE_cypherOption)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 703
-    this.match(CypherParser.CYPHER)
-    this.state = 706
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 51, this._ctx)
-    if (la_ === 1) {
-      this.state = 704
-      this.match(CypherParser.SP)
-      this.state = 705
-      this.versionNumber()
-    }
-    this.state = 712
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 52, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 708
-        this.match(CypherParser.SP)
-        this.state = 709
-        this.configurationOption()
-      }
-      this.state = 714
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 52, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function VersionNumberContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_versionNumber
-  return this
-}
-
-VersionNumberContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-VersionNumberContext.prototype.constructor = VersionNumberContext
-
-VersionNumberContext.prototype.RegularDecimalReal = function() {
-  return this.getToken(CypherParser.RegularDecimalReal, 0)
-}
-
-VersionNumberContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterVersionNumber(this)
-  }
-}
-
-VersionNumberContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitVersionNumber(this)
-  }
-}
-
-CypherParser.VersionNumberContext = VersionNumberContext
-
-CypherParser.prototype.versionNumber = function() {
-  var localctx = new VersionNumberContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 72, CypherParser.RULE_versionNumber)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 715
-    this.match(CypherParser.RegularDecimalReal)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ExplainContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_explain
-  return this
-}
-
-ExplainContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ExplainContext.prototype.constructor = ExplainContext
-
-ExplainContext.prototype.EXPLAIN = function() {
-  return this.getToken(CypherParser.EXPLAIN, 0)
-}
-
-ExplainContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterExplain(this)
-  }
-}
-
-ExplainContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitExplain(this)
-  }
-}
-
-CypherParser.ExplainContext = ExplainContext
-
-CypherParser.prototype.explain = function() {
-  var localctx = new ExplainContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 74, CypherParser.RULE_explain)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 717
-    this.match(CypherParser.EXPLAIN)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProfileContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_profile
-  return this
-}
-
-ProfileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ProfileContext.prototype.constructor = ProfileContext
-
-ProfileContext.prototype.PROFILE = function() {
-  return this.getToken(CypherParser.PROFILE, 0)
-}
-
-ProfileContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProfile(this)
-  }
-}
-
-ProfileContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProfile(this)
-  }
-}
-
-CypherParser.ProfileContext = ProfileContext
-
-CypherParser.prototype.profile = function() {
-  var localctx = new ProfileContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 76, CypherParser.RULE_profile)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 719
-    this.match(CypherParser.PROFILE)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ConfigurationOptionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_configurationOption
-  return this
-}
-
-ConfigurationOptionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ConfigurationOptionContext.prototype.constructor = ConfigurationOptionContext
-
-ConfigurationOptionContext.prototype.symbolicName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SymbolicNameContext)
-  } else {
-    return this.getTypedRuleContext(SymbolicNameContext, i)
-  }
-}
-
-ConfigurationOptionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ConfigurationOptionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterConfigurationOption(this)
-  }
-}
-
-ConfigurationOptionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitConfigurationOption(this)
-  }
-}
-
-CypherParser.ConfigurationOptionContext = ConfigurationOptionContext
-
-CypherParser.prototype.configurationOption = function() {
-  var localctx = new ConfigurationOptionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 78, CypherParser.RULE_configurationOption)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 721
-    this.symbolicName()
-    this.state = 723
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 722
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 725
-    this.match(CypherParser.T__11)
-    this.state = 727
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 726
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 729
-    this.symbolicName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function StatementContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_statement
-  return this
-}
-
-StatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-StatementContext.prototype.constructor = StatementContext
-
-StatementContext.prototype.command = function() {
-  return this.getTypedRuleContext(CommandContext, 0)
-}
-
-StatementContext.prototype.query = function() {
-  return this.getTypedRuleContext(QueryContext, 0)
-}
-
-StatementContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterStatement(this)
-  }
-}
-
-StatementContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitStatement(this)
-  }
-}
-
-CypherParser.StatementContext = StatementContext
-
-CypherParser.prototype.statement = function() {
-  var localctx = new StatementContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 80, CypherParser.RULE_statement)
-  try {
-    this.state = 733
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 55, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 731
-        this.command()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 732
-        this.query()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function QueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_query
-  return this
-}
-
-QueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-QueryContext.prototype.constructor = QueryContext
-
-QueryContext.prototype.regularQuery = function() {
-  return this.getTypedRuleContext(RegularQueryContext, 0)
-}
-
-QueryContext.prototype.bulkImportQuery = function() {
-  return this.getTypedRuleContext(BulkImportQueryContext, 0)
-}
-
-QueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterQuery(this)
-  }
-}
-
-QueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitQuery(this)
-  }
-}
-
-CypherParser.QueryContext = QueryContext
-
-CypherParser.prototype.query = function() {
-  var localctx = new QueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 82, CypherParser.RULE_query)
-  try {
-    this.state = 737
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.CREATE:
-      case CypherParser.LOAD:
-      case CypherParser.WITH:
-      case CypherParser.OPTIONAL:
-      case CypherParser.MATCH:
-      case CypherParser.UNWIND:
-      case CypherParser.MERGE:
-      case CypherParser.SET:
-      case CypherParser.DETACH:
-      case CypherParser.DELETE:
-      case CypherParser.REMOVE:
-      case CypherParser.FOREACH:
-      case CypherParser.RETURN:
-      case CypherParser.START:
-      case CypherParser.CALL:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 735
-        this.regularQuery()
-        break
-      case CypherParser.USING:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 736
-        this.bulkImportQuery()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RegularQueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_regularQuery
-  return this
-}
-
-RegularQueryContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RegularQueryContext.prototype.constructor = RegularQueryContext
-
-RegularQueryContext.prototype.singleQuery = function() {
-  return this.getTypedRuleContext(SingleQueryContext, 0)
-}
-
-RegularQueryContext.prototype.union = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(UnionContext)
-  } else {
-    return this.getTypedRuleContext(UnionContext, i)
-  }
-}
-
-RegularQueryContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RegularQueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRegularQuery(this)
-  }
-}
-
-RegularQueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRegularQuery(this)
-  }
-}
-
-CypherParser.RegularQueryContext = RegularQueryContext
-
-CypherParser.prototype.regularQuery = function() {
-  var localctx = new RegularQueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 84, CypherParser.RULE_regularQuery)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 739
-    this.singleQuery()
-    this.state = 746
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 58, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 741
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 740
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 743
-        this.union()
-      }
-      this.state = 748
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 58, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function BulkImportQueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_bulkImportQuery
-  return this
-}
-
-BulkImportQueryContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-BulkImportQueryContext.prototype.constructor = BulkImportQueryContext
-
-BulkImportQueryContext.prototype.periodicCommitHint = function() {
-  return this.getTypedRuleContext(PeriodicCommitHintContext, 0)
-}
-
-BulkImportQueryContext.prototype.loadCSVQuery = function() {
-  return this.getTypedRuleContext(LoadCSVQueryContext, 0)
-}
-
-BulkImportQueryContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-BulkImportQueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterBulkImportQuery(this)
-  }
-}
-
-BulkImportQueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitBulkImportQuery(this)
-  }
-}
-
-CypherParser.BulkImportQueryContext = BulkImportQueryContext
-
-CypherParser.prototype.bulkImportQuery = function() {
-  var localctx = new BulkImportQueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 86, CypherParser.RULE_bulkImportQuery)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 749
-    this.periodicCommitHint()
-    this.state = 751
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 750
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 753
-    this.loadCSVQuery()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SingleQueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_singleQuery
-  return this
-}
-
-SingleQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SingleQueryContext.prototype.constructor = SingleQueryContext
-
-SingleQueryContext.prototype.clause = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ClauseContext)
-  } else {
-    return this.getTypedRuleContext(ClauseContext, i)
-  }
-}
-
-SingleQueryContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-SingleQueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSingleQuery(this)
-  }
-}
-
-SingleQueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSingleQuery(this)
-  }
-}
-
-CypherParser.SingleQueryContext = SingleQueryContext
-
-CypherParser.prototype.singleQuery = function() {
-  var localctx = new SingleQueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 88, CypherParser.RULE_singleQuery)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 755
-    this.clause()
-    this.state = 762
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 61, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 757
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 756
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 759
-        this.clause()
-      }
-      this.state = 764
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 61, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PeriodicCommitHintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_periodicCommitHint
-  return this
-}
-
-PeriodicCommitHintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PeriodicCommitHintContext.prototype.constructor = PeriodicCommitHintContext
-
-PeriodicCommitHintContext.prototype.USING = function() {
-  return this.getToken(CypherParser.USING, 0)
-}
-
-PeriodicCommitHintContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PeriodicCommitHintContext.prototype.PERIODIC = function() {
-  return this.getToken(CypherParser.PERIODIC, 0)
-}
-
-PeriodicCommitHintContext.prototype.COMMIT = function() {
-  return this.getToken(CypherParser.COMMIT, 0)
-}
-
-PeriodicCommitHintContext.prototype.integerLiteral = function() {
-  return this.getTypedRuleContext(IntegerLiteralContext, 0)
-}
-
-PeriodicCommitHintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPeriodicCommitHint(this)
-  }
-}
-
-PeriodicCommitHintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPeriodicCommitHint(this)
-  }
-}
-
-CypherParser.PeriodicCommitHintContext = PeriodicCommitHintContext
-
-CypherParser.prototype.periodicCommitHint = function() {
-  var localctx = new PeriodicCommitHintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 90, CypherParser.RULE_periodicCommitHint)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 765
-    this.match(CypherParser.USING)
-    this.state = 766
-    this.match(CypherParser.SP)
-    this.state = 767
-    this.match(CypherParser.PERIODIC)
-    this.state = 768
-    this.match(CypherParser.SP)
-    this.state = 769
-    this.match(CypherParser.COMMIT)
-    this.state = 772
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 62, this._ctx)
-    if (la_ === 1) {
-      this.state = 770
-      this.match(CypherParser.SP)
-      this.state = 771
-      this.integerLiteral()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LoadCSVQueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_loadCSVQuery
-  return this
-}
-
-LoadCSVQueryContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-LoadCSVQueryContext.prototype.constructor = LoadCSVQueryContext
-
-LoadCSVQueryContext.prototype.loadCSVClause = function() {
-  return this.getTypedRuleContext(LoadCSVClauseContext, 0)
-}
-
-LoadCSVQueryContext.prototype.clause = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ClauseContext)
-  } else {
-    return this.getTypedRuleContext(ClauseContext, i)
-  }
-}
-
-LoadCSVQueryContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-LoadCSVQueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLoadCSVQuery(this)
-  }
-}
-
-LoadCSVQueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLoadCSVQuery(this)
-  }
-}
-
-CypherParser.LoadCSVQueryContext = LoadCSVQueryContext
-
-CypherParser.prototype.loadCSVQuery = function() {
-  var localctx = new LoadCSVQueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 92, CypherParser.RULE_loadCSVQuery)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 774
-    this.loadCSVClause()
-    this.state = 781
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 64, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 776
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 775
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 778
-        this.clause()
-      }
-      this.state = 783
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 64, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UnionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_union
-  return this
-}
-
-UnionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-UnionContext.prototype.constructor = UnionContext
-
-UnionContext.prototype.UNION = function() {
-  return this.getToken(CypherParser.UNION, 0)
-}
-
-UnionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-UnionContext.prototype.ALL = function() {
-  return this.getToken(CypherParser.ALL, 0)
-}
-
-UnionContext.prototype.singleQuery = function() {
-  return this.getTypedRuleContext(SingleQueryContext, 0)
-}
-
-UnionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUnion(this)
-  }
-}
-
-UnionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUnion(this)
-  }
-}
-
-CypherParser.UnionContext = UnionContext
-
-CypherParser.prototype.union = function() {
-  var localctx = new UnionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 94, CypherParser.RULE_union)
-  var _la = 0 // Token type
-  try {
-    this.state = 796
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 67, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 784
-        this.match(CypherParser.UNION)
-        this.state = 785
-        this.match(CypherParser.SP)
-        this.state = 786
-        this.match(CypherParser.ALL)
-        this.state = 788
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 787
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 790
-        this.singleQuery()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 791
-        this.match(CypherParser.UNION)
-        this.state = 793
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 792
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 795
-        this.singleQuery()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_clause
-  return this
-}
-
-ClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ClauseContext.prototype.constructor = ClauseContext
-
-ClauseContext.prototype.loadCSVClause = function() {
-  return this.getTypedRuleContext(LoadCSVClauseContext, 0)
-}
-
-ClauseContext.prototype.startClause = function() {
-  return this.getTypedRuleContext(StartClauseContext, 0)
-}
-
-ClauseContext.prototype.matchClause = function() {
-  return this.getTypedRuleContext(MatchClauseContext, 0)
-}
-
-ClauseContext.prototype.unwindClause = function() {
-  return this.getTypedRuleContext(UnwindClauseContext, 0)
-}
-
-ClauseContext.prototype.mergeClause = function() {
-  return this.getTypedRuleContext(MergeClauseContext, 0)
-}
-
-ClauseContext.prototype.createClause = function() {
-  return this.getTypedRuleContext(CreateClauseContext, 0)
-}
-
-ClauseContext.prototype.createUniqueClause = function() {
-  return this.getTypedRuleContext(CreateUniqueClauseContext, 0)
-}
-
-ClauseContext.prototype.setClause = function() {
-  return this.getTypedRuleContext(SetClauseContext, 0)
-}
-
-ClauseContext.prototype.deleteClause = function() {
-  return this.getTypedRuleContext(DeleteClauseContext, 0)
-}
-
-ClauseContext.prototype.removeClause = function() {
-  return this.getTypedRuleContext(RemoveClauseContext, 0)
-}
-
-ClauseContext.prototype.foreachClause = function() {
-  return this.getTypedRuleContext(ForeachClauseContext, 0)
-}
-
-ClauseContext.prototype.withClause = function() {
-  return this.getTypedRuleContext(WithClauseContext, 0)
-}
-
-ClauseContext.prototype.returnClause = function() {
-  return this.getTypedRuleContext(ReturnClauseContext, 0)
-}
-
-ClauseContext.prototype.call = function() {
-  return this.getTypedRuleContext(CallContext, 0)
-}
-
-ClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterClause(this)
-  }
-}
-
-ClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitClause(this)
-  }
-}
-
-CypherParser.ClauseContext = ClauseContext
-
-CypherParser.prototype.clause = function() {
-  var localctx = new ClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 96, CypherParser.RULE_clause)
-  try {
-    this.state = 812
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 68, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 798
-        this.loadCSVClause()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 799
-        this.startClause()
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 800
-        this.matchClause()
-        break
-
-      case 4:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 801
-        this.unwindClause()
-        break
-
-      case 5:
-        this.enterOuterAlt(localctx, 5)
-        this.state = 802
-        this.mergeClause()
-        break
-
-      case 6:
-        this.enterOuterAlt(localctx, 6)
-        this.state = 803
-        this.createClause()
-        break
-
-      case 7:
-        this.enterOuterAlt(localctx, 7)
-        this.state = 804
-        this.createUniqueClause()
-        break
-
-      case 8:
-        this.enterOuterAlt(localctx, 8)
-        this.state = 805
-        this.setClause()
-        break
-
-      case 9:
-        this.enterOuterAlt(localctx, 9)
-        this.state = 806
-        this.deleteClause()
-        break
-
-      case 10:
-        this.enterOuterAlt(localctx, 10)
-        this.state = 807
-        this.removeClause()
-        break
-
-      case 11:
-        this.enterOuterAlt(localctx, 11)
-        this.state = 808
-        this.foreachClause()
-        break
-
-      case 12:
-        this.enterOuterAlt(localctx, 12)
-        this.state = 809
-        this.withClause()
-        break
-
-      case 13:
-        this.enterOuterAlt(localctx, 13)
-        this.state = 810
-        this.returnClause()
-        break
-
-      case 14:
-        this.enterOuterAlt(localctx, 14)
-        this.state = 811
-        this.call()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CommandContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_command
-  return this
-}
-
-CommandContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-CommandContext.prototype.constructor = CommandContext
-
-CommandContext.prototype.createIndex = function() {
-  return this.getTypedRuleContext(CreateIndexContext, 0)
-}
-
-CommandContext.prototype.dropIndex = function() {
-  return this.getTypedRuleContext(DropIndexContext, 0)
-}
-
-CommandContext.prototype.createUniqueConstraint = function() {
-  return this.getTypedRuleContext(CreateUniqueConstraintContext, 0)
-}
-
-CommandContext.prototype.dropUniqueConstraint = function() {
-  return this.getTypedRuleContext(DropUniqueConstraintContext, 0)
-}
-
-CommandContext.prototype.createNodeKeyConstraint = function() {
-  return this.getTypedRuleContext(CreateNodeKeyConstraintContext, 0)
-}
-
-CommandContext.prototype.dropNodeKeyConstraint = function() {
-  return this.getTypedRuleContext(DropNodeKeyConstraintContext, 0)
-}
-
-CommandContext.prototype.createNodePropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(
-    CreateNodePropertyExistenceConstraintContext,
-    0
-  )
-}
-
-CommandContext.prototype.dropNodePropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(DropNodePropertyExistenceConstraintContext, 0)
-}
-
-CommandContext.prototype.createRelationshipPropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(
-    CreateRelationshipPropertyExistenceConstraintContext,
-    0
-  )
-}
-
-CommandContext.prototype.dropRelationshipPropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(
-    DropRelationshipPropertyExistenceConstraintContext,
-    0
-  )
-}
-
-CommandContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCommand(this)
-  }
-}
-
-CommandContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCommand(this)
-  }
-}
-
-CypherParser.CommandContext = CommandContext
-
-CypherParser.prototype.command = function() {
-  var localctx = new CommandContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 98, CypherParser.RULE_command)
-  try {
-    this.state = 824
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 69, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 814
-        this.createIndex()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 815
-        this.dropIndex()
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 816
-        this.createUniqueConstraint()
-        break
-
-      case 4:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 817
-        this.dropUniqueConstraint()
-        break
-
-      case 5:
-        this.enterOuterAlt(localctx, 5)
-        this.state = 818
-        this.createNodeKeyConstraint()
-        break
-
-      case 6:
-        this.enterOuterAlt(localctx, 6)
-        this.state = 819
-        this.dropNodeKeyConstraint()
-        break
-
-      case 7:
-        this.enterOuterAlt(localctx, 7)
-        this.state = 820
-        this.createNodePropertyExistenceConstraint()
-        break
-
-      case 8:
-        this.enterOuterAlt(localctx, 8)
-        this.state = 821
-        this.dropNodePropertyExistenceConstraint()
-        break
-
-      case 9:
-        this.enterOuterAlt(localctx, 9)
-        this.state = 822
-        this.createRelationshipPropertyExistenceConstraint()
-        break
-
-      case 10:
-        this.enterOuterAlt(localctx, 10)
-        this.state = 823
-        this.dropRelationshipPropertyExistenceConstraint()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CreateUniqueConstraintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_createUniqueConstraint
-  return this
-}
-
-CreateUniqueConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CreateUniqueConstraintContext.prototype.constructor = CreateUniqueConstraintContext
-
-CreateUniqueConstraintContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-CreateUniqueConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-CreateUniqueConstraintContext.prototype.uniqueConstraint = function() {
-  return this.getTypedRuleContext(UniqueConstraintContext, 0)
-}
-
-CreateUniqueConstraintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCreateUniqueConstraint(this)
-  }
-}
-
-CreateUniqueConstraintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCreateUniqueConstraint(this)
-  }
-}
-
-CypherParser.CreateUniqueConstraintContext = CreateUniqueConstraintContext
-
-CypherParser.prototype.createUniqueConstraint = function() {
-  var localctx = new CreateUniqueConstraintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 100, CypherParser.RULE_createUniqueConstraint)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 826
-    this.match(CypherParser.CREATE)
-    this.state = 827
-    this.match(CypherParser.SP)
-    this.state = 828
-    this.uniqueConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CreateNodeKeyConstraintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_createNodeKeyConstraint
-  return this
-}
-
-CreateNodeKeyConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CreateNodeKeyConstraintContext.prototype.constructor = CreateNodeKeyConstraintContext
-
-CreateNodeKeyConstraintContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-CreateNodeKeyConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-CreateNodeKeyConstraintContext.prototype.nodeKeyConstraint = function() {
-  return this.getTypedRuleContext(NodeKeyConstraintContext, 0)
-}
-
-CreateNodeKeyConstraintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCreateNodeKeyConstraint(this)
-  }
-}
-
-CreateNodeKeyConstraintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCreateNodeKeyConstraint(this)
-  }
-}
-
-CypherParser.CreateNodeKeyConstraintContext = CreateNodeKeyConstraintContext
-
-CypherParser.prototype.createNodeKeyConstraint = function() {
-  var localctx = new CreateNodeKeyConstraintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 102, CypherParser.RULE_createNodeKeyConstraint)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 830
-    this.match(CypherParser.CREATE)
-    this.state = 831
-    this.match(CypherParser.SP)
-    this.state = 832
-    this.nodeKeyConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CreateNodePropertyExistenceConstraintContext(
-  parser,
-  parent,
-  invokingState
-) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_createNodePropertyExistenceConstraint
-  return this
-}
-
-CreateNodePropertyExistenceConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CreateNodePropertyExistenceConstraintContext.prototype.constructor = CreateNodePropertyExistenceConstraintContext
-
-CreateNodePropertyExistenceConstraintContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-CreateNodePropertyExistenceConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-CreateNodePropertyExistenceConstraintContext.prototype.nodePropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(NodePropertyExistenceConstraintContext, 0)
-}
-
-CreateNodePropertyExistenceConstraintContext.prototype.enterRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.enterCreateNodePropertyExistenceConstraint(this)
-  }
-}
-
-CreateNodePropertyExistenceConstraintContext.prototype.exitRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.exitCreateNodePropertyExistenceConstraint(this)
-  }
-}
-
-CypherParser.CreateNodePropertyExistenceConstraintContext = CreateNodePropertyExistenceConstraintContext
-
-CypherParser.prototype.createNodePropertyExistenceConstraint = function() {
-  var localctx = new CreateNodePropertyExistenceConstraintContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    104,
-    CypherParser.RULE_createNodePropertyExistenceConstraint
-  )
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 834
-    this.match(CypherParser.CREATE)
-    this.state = 835
-    this.match(CypherParser.SP)
-    this.state = 836
-    this.nodePropertyExistenceConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CreateRelationshipPropertyExistenceConstraintContext(
-  parser,
-  parent,
-  invokingState
-) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex =
-    CypherParser.RULE_createRelationshipPropertyExistenceConstraint
-  return this
-}
-
-CreateRelationshipPropertyExistenceConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CreateRelationshipPropertyExistenceConstraintContext.prototype.constructor = CreateRelationshipPropertyExistenceConstraintContext
-
-CreateRelationshipPropertyExistenceConstraintContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-CreateRelationshipPropertyExistenceConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-CreateRelationshipPropertyExistenceConstraintContext.prototype.relationshipPropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(
-    RelationshipPropertyExistenceConstraintContext,
-    0
-  )
-}
-
-CreateRelationshipPropertyExistenceConstraintContext.prototype.enterRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.enterCreateRelationshipPropertyExistenceConstraint(this)
-  }
-}
-
-CreateRelationshipPropertyExistenceConstraintContext.prototype.exitRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.exitCreateRelationshipPropertyExistenceConstraint(this)
-  }
-}
-
-CypherParser.CreateRelationshipPropertyExistenceConstraintContext = CreateRelationshipPropertyExistenceConstraintContext
-
-CypherParser.prototype.createRelationshipPropertyExistenceConstraint = function() {
-  var localctx = new CreateRelationshipPropertyExistenceConstraintContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    106,
-    CypherParser.RULE_createRelationshipPropertyExistenceConstraint
-  )
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 838
-    this.match(CypherParser.CREATE)
-    this.state = 839
-    this.match(CypherParser.SP)
-    this.state = 840
-    this.relationshipPropertyExistenceConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CreateIndexContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_createIndex
-  return this
-}
-
-CreateIndexContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-CreateIndexContext.prototype.constructor = CreateIndexContext
-
-CreateIndexContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-CreateIndexContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-CreateIndexContext.prototype.index = function() {
-  return this.getTypedRuleContext(IndexContext, 0)
-}
-
-CreateIndexContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCreateIndex(this)
-  }
-}
-
-CreateIndexContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCreateIndex(this)
-  }
-}
-
-CypherParser.CreateIndexContext = CreateIndexContext
-
-CypherParser.prototype.createIndex = function() {
-  var localctx = new CreateIndexContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 108, CypherParser.RULE_createIndex)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 842
-    this.match(CypherParser.CREATE)
-    this.state = 843
-    this.match(CypherParser.SP)
-    this.state = 844
-    this.index()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DropUniqueConstraintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_dropUniqueConstraint
-  return this
-}
-
-DropUniqueConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-DropUniqueConstraintContext.prototype.constructor = DropUniqueConstraintContext
-
-DropUniqueConstraintContext.prototype.DROP = function() {
-  return this.getToken(CypherParser.DROP, 0)
-}
-
-DropUniqueConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-DropUniqueConstraintContext.prototype.uniqueConstraint = function() {
-  return this.getTypedRuleContext(UniqueConstraintContext, 0)
-}
-
-DropUniqueConstraintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterDropUniqueConstraint(this)
-  }
-}
-
-DropUniqueConstraintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitDropUniqueConstraint(this)
-  }
-}
-
-CypherParser.DropUniqueConstraintContext = DropUniqueConstraintContext
-
-CypherParser.prototype.dropUniqueConstraint = function() {
-  var localctx = new DropUniqueConstraintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 110, CypherParser.RULE_dropUniqueConstraint)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 846
-    this.match(CypherParser.DROP)
-    this.state = 847
-    this.match(CypherParser.SP)
-    this.state = 848
-    this.uniqueConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DropNodeKeyConstraintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_dropNodeKeyConstraint
-  return this
-}
-
-DropNodeKeyConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-DropNodeKeyConstraintContext.prototype.constructor = DropNodeKeyConstraintContext
-
-DropNodeKeyConstraintContext.prototype.DROP = function() {
-  return this.getToken(CypherParser.DROP, 0)
-}
-
-DropNodeKeyConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-DropNodeKeyConstraintContext.prototype.nodeKeyConstraint = function() {
-  return this.getTypedRuleContext(NodeKeyConstraintContext, 0)
-}
-
-DropNodeKeyConstraintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterDropNodeKeyConstraint(this)
-  }
-}
-
-DropNodeKeyConstraintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitDropNodeKeyConstraint(this)
-  }
-}
-
-CypherParser.DropNodeKeyConstraintContext = DropNodeKeyConstraintContext
-
-CypherParser.prototype.dropNodeKeyConstraint = function() {
-  var localctx = new DropNodeKeyConstraintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 112, CypherParser.RULE_dropNodeKeyConstraint)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 850
-    this.match(CypherParser.DROP)
-    this.state = 851
-    this.match(CypherParser.SP)
-    this.state = 852
-    this.nodeKeyConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DropNodePropertyExistenceConstraintContext(
-  parser,
-  parent,
-  invokingState
-) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_dropNodePropertyExistenceConstraint
-  return this
-}
-
-DropNodePropertyExistenceConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-DropNodePropertyExistenceConstraintContext.prototype.constructor = DropNodePropertyExistenceConstraintContext
-
-DropNodePropertyExistenceConstraintContext.prototype.DROP = function() {
-  return this.getToken(CypherParser.DROP, 0)
-}
-
-DropNodePropertyExistenceConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-DropNodePropertyExistenceConstraintContext.prototype.nodePropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(NodePropertyExistenceConstraintContext, 0)
-}
-
-DropNodePropertyExistenceConstraintContext.prototype.enterRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.enterDropNodePropertyExistenceConstraint(this)
-  }
-}
-
-DropNodePropertyExistenceConstraintContext.prototype.exitRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.exitDropNodePropertyExistenceConstraint(this)
-  }
-}
-
-CypherParser.DropNodePropertyExistenceConstraintContext = DropNodePropertyExistenceConstraintContext
-
-CypherParser.prototype.dropNodePropertyExistenceConstraint = function() {
-  var localctx = new DropNodePropertyExistenceConstraintContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    114,
-    CypherParser.RULE_dropNodePropertyExistenceConstraint
-  )
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 854
-    this.match(CypherParser.DROP)
-    this.state = 855
-    this.match(CypherParser.SP)
-    this.state = 856
-    this.nodePropertyExistenceConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DropRelationshipPropertyExistenceConstraintContext(
-  parser,
-  parent,
-  invokingState
-) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_dropRelationshipPropertyExistenceConstraint
-  return this
-}
-
-DropRelationshipPropertyExistenceConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-DropRelationshipPropertyExistenceConstraintContext.prototype.constructor = DropRelationshipPropertyExistenceConstraintContext
-
-DropRelationshipPropertyExistenceConstraintContext.prototype.DROP = function() {
-  return this.getToken(CypherParser.DROP, 0)
-}
-
-DropRelationshipPropertyExistenceConstraintContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-DropRelationshipPropertyExistenceConstraintContext.prototype.relationshipPropertyExistenceConstraint = function() {
-  return this.getTypedRuleContext(
-    RelationshipPropertyExistenceConstraintContext,
-    0
-  )
-}
-
-DropRelationshipPropertyExistenceConstraintContext.prototype.enterRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.enterDropRelationshipPropertyExistenceConstraint(this)
-  }
-}
-
-DropRelationshipPropertyExistenceConstraintContext.prototype.exitRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.exitDropRelationshipPropertyExistenceConstraint(this)
-  }
-}
-
-CypherParser.DropRelationshipPropertyExistenceConstraintContext = DropRelationshipPropertyExistenceConstraintContext
-
-CypherParser.prototype.dropRelationshipPropertyExistenceConstraint = function() {
-  var localctx = new DropRelationshipPropertyExistenceConstraintContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    116,
-    CypherParser.RULE_dropRelationshipPropertyExistenceConstraint
-  )
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 858
-    this.match(CypherParser.DROP)
-    this.state = 859
-    this.match(CypherParser.SP)
-    this.state = 860
-    this.relationshipPropertyExistenceConstraint()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DropIndexContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_dropIndex
-  return this
-}
-
-DropIndexContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-DropIndexContext.prototype.constructor = DropIndexContext
-
-DropIndexContext.prototype.DROP = function() {
-  return this.getToken(CypherParser.DROP, 0)
-}
-
-DropIndexContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-DropIndexContext.prototype.index = function() {
-  return this.getTypedRuleContext(IndexContext, 0)
-}
-
-DropIndexContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterDropIndex(this)
-  }
-}
-
-DropIndexContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitDropIndex(this)
-  }
-}
-
-CypherParser.DropIndexContext = DropIndexContext
-
-CypherParser.prototype.dropIndex = function() {
-  var localctx = new DropIndexContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 118, CypherParser.RULE_dropIndex)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 862
-    this.match(CypherParser.DROP)
-    this.state = 863
-    this.match(CypherParser.SP)
-    this.state = 864
-    this.index()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function IndexContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_index
-  return this
-}
-
-IndexContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-IndexContext.prototype.constructor = IndexContext
-
-IndexContext.prototype.INDEX = function() {
-  return this.getToken(CypherParser.INDEX, 0)
-}
-
-IndexContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-IndexContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-IndexContext.prototype.nodeLabel = function() {
-  return this.getTypedRuleContext(NodeLabelContext, 0)
-}
-
-IndexContext.prototype.propertyKeys = function() {
-  return this.getTypedRuleContext(PropertyKeysContext, 0)
-}
-
-IndexContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterIndex(this)
-  }
-}
-
-IndexContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitIndex(this)
-  }
-}
-
-CypherParser.IndexContext = IndexContext
-
-CypherParser.prototype.index = function() {
-  var localctx = new IndexContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 120, CypherParser.RULE_index)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 866
-    this.match(CypherParser.INDEX)
-    this.state = 867
-    this.match(CypherParser.SP)
-    this.state = 868
-    this.match(CypherParser.ON)
-    this.state = 870
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 869
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 872
-    this.nodeLabel()
-    this.state = 874
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 873
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 876
-    this.match(CypherParser.T__18)
-    this.state = 878
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 877
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 880
-    this.propertyKeys()
-    this.state = 882
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 881
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 884
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UniqueConstraintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_uniqueConstraint
-  return this
-}
-
-UniqueConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-UniqueConstraintContext.prototype.constructor = UniqueConstraintContext
-
-UniqueConstraintContext.prototype.CONSTRAINT = function() {
-  return this.getToken(CypherParser.CONSTRAINT, 0)
-}
-
-UniqueConstraintContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-UniqueConstraintContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-UniqueConstraintContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-UniqueConstraintContext.prototype.nodeLabel = function() {
-  return this.getTypedRuleContext(NodeLabelContext, 0)
-}
-
-UniqueConstraintContext.prototype.ASSERT = function() {
-  return this.getToken(CypherParser.ASSERT, 0)
-}
-
-UniqueConstraintContext.prototype.propertyExpression = function() {
-  return this.getTypedRuleContext(PropertyExpressionContext, 0)
-}
-
-UniqueConstraintContext.prototype.IS = function() {
-  return this.getToken(CypherParser.IS, 0)
-}
-
-UniqueConstraintContext.prototype.UNIQUE = function() {
-  return this.getToken(CypherParser.UNIQUE, 0)
-}
-
-UniqueConstraintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUniqueConstraint(this)
-  }
-}
-
-UniqueConstraintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUniqueConstraint(this)
-  }
-}
-
-CypherParser.UniqueConstraintContext = UniqueConstraintContext
-
-CypherParser.prototype.uniqueConstraint = function() {
-  var localctx = new UniqueConstraintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 122, CypherParser.RULE_uniqueConstraint)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 886
-    this.match(CypherParser.CONSTRAINT)
-    this.state = 887
-    this.match(CypherParser.SP)
-    this.state = 888
-    this.match(CypherParser.ON)
-    this.state = 890
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 889
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 892
-    this.match(CypherParser.T__18)
-    this.state = 894
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 893
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 896
-    this.variable()
-    this.state = 897
-    this.nodeLabel()
-    this.state = 899
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 898
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 901
-    this.match(CypherParser.T__19)
-    this.state = 903
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 902
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 905
-    this.match(CypherParser.ASSERT)
-    this.state = 906
-    this.match(CypherParser.SP)
-    this.state = 907
-    this.propertyExpression()
-    this.state = 908
-    this.match(CypherParser.SP)
-    this.state = 909
-    this.match(CypherParser.IS)
-    this.state = 910
-    this.match(CypherParser.SP)
-    this.state = 911
-    this.match(CypherParser.UNIQUE)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NodeKeyConstraintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_nodeKeyConstraint
-  return this
-}
-
-NodeKeyConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-NodeKeyConstraintContext.prototype.constructor = NodeKeyConstraintContext
-
-NodeKeyConstraintContext.prototype.CONSTRAINT = function() {
-  return this.getToken(CypherParser.CONSTRAINT, 0)
-}
-
-NodeKeyConstraintContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-NodeKeyConstraintContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-NodeKeyConstraintContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-NodeKeyConstraintContext.prototype.nodeLabel = function() {
-  return this.getTypedRuleContext(NodeLabelContext, 0)
-}
-
-NodeKeyConstraintContext.prototype.ASSERT = function() {
-  return this.getToken(CypherParser.ASSERT, 0)
-}
-
-NodeKeyConstraintContext.prototype.propertyExpressions = function() {
-  return this.getTypedRuleContext(PropertyExpressionsContext, 0)
-}
-
-NodeKeyConstraintContext.prototype.IS = function() {
-  return this.getToken(CypherParser.IS, 0)
-}
-
-NodeKeyConstraintContext.prototype.NODE = function() {
-  return this.getToken(CypherParser.NODE, 0)
-}
-
-NodeKeyConstraintContext.prototype.KEY = function() {
-  return this.getToken(CypherParser.KEY, 0)
-}
-
-NodeKeyConstraintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNodeKeyConstraint(this)
-  }
-}
-
-NodeKeyConstraintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNodeKeyConstraint(this)
-  }
-}
-
-CypherParser.NodeKeyConstraintContext = NodeKeyConstraintContext
-
-CypherParser.prototype.nodeKeyConstraint = function() {
-  var localctx = new NodeKeyConstraintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 124, CypherParser.RULE_nodeKeyConstraint)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 913
-    this.match(CypherParser.CONSTRAINT)
-    this.state = 914
-    this.match(CypherParser.SP)
-    this.state = 915
-    this.match(CypherParser.ON)
-    this.state = 917
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 916
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 919
-    this.match(CypherParser.T__18)
-    this.state = 921
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 920
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 923
-    this.variable()
-    this.state = 924
-    this.nodeLabel()
-    this.state = 926
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 925
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 928
-    this.match(CypherParser.T__19)
-    this.state = 930
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 929
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 932
-    this.match(CypherParser.ASSERT)
-    this.state = 933
-    this.match(CypherParser.SP)
-    this.state = 934
-    this.match(CypherParser.T__18)
-    this.state = 936
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 935
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 938
-    this.propertyExpressions()
-    this.state = 940
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 939
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 942
-    this.match(CypherParser.T__19)
-    this.state = 943
-    this.match(CypherParser.SP)
-    this.state = 944
-    this.match(CypherParser.IS)
-    this.state = 945
-    this.match(CypherParser.SP)
-    this.state = 946
-    this.match(CypherParser.NODE)
-    this.state = 947
-    this.match(CypherParser.SP)
-    this.state = 948
-    this.match(CypherParser.KEY)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NodePropertyExistenceConstraintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_nodePropertyExistenceConstraint
-  return this
-}
-
-NodePropertyExistenceConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-NodePropertyExistenceConstraintContext.prototype.constructor = NodePropertyExistenceConstraintContext
-
-NodePropertyExistenceConstraintContext.prototype.CONSTRAINT = function() {
-  return this.getToken(CypherParser.CONSTRAINT, 0)
-}
-
-NodePropertyExistenceConstraintContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-NodePropertyExistenceConstraintContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-NodePropertyExistenceConstraintContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-NodePropertyExistenceConstraintContext.prototype.nodeLabel = function() {
-  return this.getTypedRuleContext(NodeLabelContext, 0)
-}
-
-NodePropertyExistenceConstraintContext.prototype.ASSERT = function() {
-  return this.getToken(CypherParser.ASSERT, 0)
-}
-
-NodePropertyExistenceConstraintContext.prototype.EXISTS = function() {
-  return this.getToken(CypherParser.EXISTS, 0)
-}
-
-NodePropertyExistenceConstraintContext.prototype.propertyExpression = function() {
-  return this.getTypedRuleContext(PropertyExpressionContext, 0)
-}
-
-NodePropertyExistenceConstraintContext.prototype.enterRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.enterNodePropertyExistenceConstraint(this)
-  }
-}
-
-NodePropertyExistenceConstraintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNodePropertyExistenceConstraint(this)
-  }
-}
-
-CypherParser.NodePropertyExistenceConstraintContext = NodePropertyExistenceConstraintContext
-
-CypherParser.prototype.nodePropertyExistenceConstraint = function() {
-  var localctx = new NodePropertyExistenceConstraintContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    126,
-    CypherParser.RULE_nodePropertyExistenceConstraint
-  )
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 950
-    this.match(CypherParser.CONSTRAINT)
-    this.state = 951
-    this.match(CypherParser.SP)
-    this.state = 952
-    this.match(CypherParser.ON)
-    this.state = 954
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 953
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 956
-    this.match(CypherParser.T__18)
-    this.state = 957
-    this.variable()
-    this.state = 958
-    this.nodeLabel()
-    this.state = 959
-    this.match(CypherParser.T__19)
-    this.state = 961
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 960
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 963
-    this.match(CypherParser.ASSERT)
-    this.state = 964
-    this.match(CypherParser.SP)
-    this.state = 965
-    this.match(CypherParser.EXISTS)
-    this.state = 967
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 966
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 969
-    this.match(CypherParser.T__18)
-    this.state = 970
-    this.propertyExpression()
-    this.state = 971
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipPropertyExistenceConstraintContext(
-  parser,
-  parent,
-  invokingState
-) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipPropertyExistenceConstraint
-  return this
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipPropertyExistenceConstraintContext.prototype.constructor = RelationshipPropertyExistenceConstraintContext
-
-RelationshipPropertyExistenceConstraintContext.prototype.CONSTRAINT = function() {
-  return this.getToken(CypherParser.CONSTRAINT, 0)
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.relationshipPatternSyntax = function() {
-  return this.getTypedRuleContext(RelationshipPatternSyntaxContext, 0)
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.ASSERT = function() {
-  return this.getToken(CypherParser.ASSERT, 0)
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.EXISTS = function() {
-  return this.getToken(CypherParser.EXISTS, 0)
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.propertyExpression = function() {
-  return this.getTypedRuleContext(PropertyExpressionContext, 0)
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.enterRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipPropertyExistenceConstraint(this)
-  }
-}
-
-RelationshipPropertyExistenceConstraintContext.prototype.exitRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipPropertyExistenceConstraint(this)
-  }
-}
-
-CypherParser.RelationshipPropertyExistenceConstraintContext = RelationshipPropertyExistenceConstraintContext
-
-CypherParser.prototype.relationshipPropertyExistenceConstraint = function() {
-  var localctx = new RelationshipPropertyExistenceConstraintContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    128,
-    CypherParser.RULE_relationshipPropertyExistenceConstraint
-  )
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 973
-    this.match(CypherParser.CONSTRAINT)
-    this.state = 974
-    this.match(CypherParser.SP)
-    this.state = 975
-    this.match(CypherParser.ON)
-    this.state = 977
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 976
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 979
-    this.relationshipPatternSyntax()
-    this.state = 981
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 980
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 983
-    this.match(CypherParser.ASSERT)
-    this.state = 984
-    this.match(CypherParser.SP)
-    this.state = 985
-    this.match(CypherParser.EXISTS)
-    this.state = 987
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 986
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 989
-    this.match(CypherParser.T__18)
-    this.state = 990
-    this.propertyExpression()
-    this.state = 991
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipPatternSyntaxContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipPatternSyntax
-  return this
-}
-
-RelationshipPatternSyntaxContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipPatternSyntaxContext.prototype.constructor = RelationshipPatternSyntaxContext
-
-RelationshipPatternSyntaxContext.prototype.dash = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(DashContext)
-  } else {
-    return this.getTypedRuleContext(DashContext, i)
-  }
-}
-
-RelationshipPatternSyntaxContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-RelationshipPatternSyntaxContext.prototype.relType = function() {
-  return this.getTypedRuleContext(RelTypeContext, 0)
-}
-
-RelationshipPatternSyntaxContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RelationshipPatternSyntaxContext.prototype.rightArrowHead = function() {
-  return this.getTypedRuleContext(RightArrowHeadContext, 0)
-}
-
-RelationshipPatternSyntaxContext.prototype.leftArrowHead = function() {
-  return this.getTypedRuleContext(LeftArrowHeadContext, 0)
-}
-
-RelationshipPatternSyntaxContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipPatternSyntax(this)
-  }
-}
-
-RelationshipPatternSyntaxContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipPatternSyntax(this)
-  }
-}
-
-CypherParser.RelationshipPatternSyntaxContext = RelationshipPatternSyntaxContext
-
-CypherParser.prototype.relationshipPatternSyntax = function() {
-  var localctx = new RelationshipPatternSyntaxContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 130, CypherParser.RULE_relationshipPatternSyntax)
-  var _la = 0 // Token type
-  try {
-    this.state = 1046
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 96, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 993
-        this.match(CypherParser.T__18)
-        this.state = 995
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 994
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 997
-        this.match(CypherParser.T__19)
-        this.state = 998
-        this.dash()
-        this.state = 999
-        this.match(CypherParser.T__16)
-        this.state = 1000
-        this.variable()
-        this.state = 1001
-        this.relType()
-        this.state = 1002
-        this.match(CypherParser.T__17)
-        this.state = 1003
-        this.dash()
-        this.state = 1004
-        this.match(CypherParser.T__18)
-        this.state = 1006
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1005
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1008
-        this.match(CypherParser.T__19)
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1010
-        this.match(CypherParser.T__18)
-        this.state = 1012
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1011
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1014
-        this.match(CypherParser.T__19)
-        this.state = 1015
-        this.dash()
-        this.state = 1016
-        this.match(CypherParser.T__16)
-        this.state = 1017
-        this.variable()
-        this.state = 1018
-        this.relType()
-        this.state = 1019
-        this.match(CypherParser.T__17)
-        this.state = 1020
-        this.dash()
-        this.state = 1021
-        this.rightArrowHead()
-        this.state = 1022
-        this.match(CypherParser.T__18)
-        this.state = 1024
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1023
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1026
-        this.match(CypherParser.T__19)
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 1028
-        this.match(CypherParser.T__18)
-        this.state = 1030
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1029
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1032
-        this.match(CypherParser.T__19)
-        this.state = 1033
-        this.leftArrowHead()
-        this.state = 1034
-        this.dash()
-        this.state = 1035
-        this.match(CypherParser.T__16)
-        this.state = 1036
-        this.variable()
-        this.state = 1037
-        this.relType()
-        this.state = 1038
-        this.match(CypherParser.T__17)
-        this.state = 1039
-        this.dash()
-        this.state = 1040
-        this.match(CypherParser.T__18)
-        this.state = 1042
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1041
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1044
-        this.match(CypherParser.T__19)
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LoadCSVClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_loadCSVClause
-  return this
-}
-
-LoadCSVClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-LoadCSVClauseContext.prototype.constructor = LoadCSVClauseContext
-
-LoadCSVClauseContext.prototype.LOAD = function() {
-  return this.getToken(CypherParser.LOAD, 0)
-}
-
-LoadCSVClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-LoadCSVClauseContext.prototype.CSV = function() {
-  return this.getToken(CypherParser.CSV, 0)
-}
-
-LoadCSVClauseContext.prototype.FROM = function() {
-  return this.getToken(CypherParser.FROM, 0)
-}
-
-LoadCSVClauseContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-LoadCSVClauseContext.prototype.AS = function() {
-  return this.getToken(CypherParser.AS, 0)
-}
-
-LoadCSVClauseContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-LoadCSVClauseContext.prototype.WITH = function() {
-  return this.getToken(CypherParser.WITH, 0)
-}
-
-LoadCSVClauseContext.prototype.HEADERS = function() {
-  return this.getToken(CypherParser.HEADERS, 0)
-}
-
-LoadCSVClauseContext.prototype.FIELDTERMINATOR = function() {
-  return this.getToken(CypherParser.FIELDTERMINATOR, 0)
-}
-
-LoadCSVClauseContext.prototype.StringLiteral = function() {
-  return this.getToken(CypherParser.StringLiteral, 0)
-}
-
-LoadCSVClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLoadCSVClause(this)
-  }
-}
-
-LoadCSVClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLoadCSVClause(this)
-  }
-}
-
-CypherParser.LoadCSVClauseContext = LoadCSVClauseContext
-
-CypherParser.prototype.loadCSVClause = function() {
-  var localctx = new LoadCSVClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 132, CypherParser.RULE_loadCSVClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1048
-    this.match(CypherParser.LOAD)
-    this.state = 1049
-    this.match(CypherParser.SP)
-    this.state = 1050
-    this.match(CypherParser.CSV)
-    this.state = 1051
-    this.match(CypherParser.SP)
-    this.state = 1056
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.WITH) {
-      this.state = 1052
-      this.match(CypherParser.WITH)
-      this.state = 1053
-      this.match(CypherParser.SP)
-      this.state = 1054
-      this.match(CypherParser.HEADERS)
-      this.state = 1055
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1058
-    this.match(CypherParser.FROM)
-    this.state = 1059
-    this.match(CypherParser.SP)
-    this.state = 1060
-    this.expression()
-    this.state = 1061
-    this.match(CypherParser.SP)
-    this.state = 1062
-    this.match(CypherParser.AS)
-    this.state = 1063
-    this.match(CypherParser.SP)
-    this.state = 1064
-    this.variable()
-    this.state = 1065
-    this.match(CypherParser.SP)
-    this.state = 1069
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.FIELDTERMINATOR) {
-      this.state = 1066
-      this.match(CypherParser.FIELDTERMINATOR)
-      this.state = 1067
-      this.match(CypherParser.SP)
-      this.state = 1068
-      this.match(CypherParser.StringLiteral)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function MatchClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_matchClause
-  return this
-}
-
-MatchClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-MatchClauseContext.prototype.constructor = MatchClauseContext
-
-MatchClauseContext.prototype.MATCH = function() {
-  return this.getToken(CypherParser.MATCH, 0)
-}
-
-MatchClauseContext.prototype.pattern = function() {
-  return this.getTypedRuleContext(PatternContext, 0)
-}
-
-MatchClauseContext.prototype.OPTIONAL = function() {
-  return this.getToken(CypherParser.OPTIONAL, 0)
-}
-
-MatchClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-MatchClauseContext.prototype.hint = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(HintContext)
-  } else {
-    return this.getTypedRuleContext(HintContext, i)
-  }
-}
-
-MatchClauseContext.prototype.where = function() {
-  return this.getTypedRuleContext(WhereContext, 0)
-}
-
-MatchClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterMatchClause(this)
-  }
-}
-
-MatchClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitMatchClause(this)
-  }
-}
-
-CypherParser.MatchClauseContext = MatchClauseContext
-
-CypherParser.prototype.matchClause = function() {
-  var localctx = new MatchClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 134, CypherParser.RULE_matchClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1073
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.OPTIONAL) {
-      this.state = 1071
-      this.match(CypherParser.OPTIONAL)
-      this.state = 1072
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1075
-    this.match(CypherParser.MATCH)
-    this.state = 1077
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1076
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1079
-    this.pattern()
-    this.state = 1083
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 101, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1080
-        this.hint()
-      }
-      this.state = 1085
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 101, this._ctx)
-    }
-
-    this.state = 1090
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 103, this._ctx)
-    if (la_ === 1) {
-      this.state = 1087
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1086
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1089
-      this.where()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UnwindClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_unwindClause
-  return this
-}
-
-UnwindClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-UnwindClauseContext.prototype.constructor = UnwindClauseContext
-
-UnwindClauseContext.prototype.UNWIND = function() {
-  return this.getToken(CypherParser.UNWIND, 0)
-}
-
-UnwindClauseContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-UnwindClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-UnwindClauseContext.prototype.AS = function() {
-  return this.getToken(CypherParser.AS, 0)
-}
-
-UnwindClauseContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-UnwindClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUnwindClause(this)
-  }
-}
-
-UnwindClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUnwindClause(this)
-  }
-}
-
-CypherParser.UnwindClauseContext = UnwindClauseContext
-
-CypherParser.prototype.unwindClause = function() {
-  var localctx = new UnwindClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 136, CypherParser.RULE_unwindClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1092
-    this.match(CypherParser.UNWIND)
-    this.state = 1094
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1093
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1096
-    this.expression()
-    this.state = 1097
-    this.match(CypherParser.SP)
-    this.state = 1098
-    this.match(CypherParser.AS)
-    this.state = 1099
-    this.match(CypherParser.SP)
-    this.state = 1100
-    this.variable()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function MergeClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_mergeClause
-  return this
-}
-
-MergeClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-MergeClauseContext.prototype.constructor = MergeClauseContext
-
-MergeClauseContext.prototype.MERGE = function() {
-  return this.getToken(CypherParser.MERGE, 0)
-}
-
-MergeClauseContext.prototype.patternPart = function() {
-  return this.getTypedRuleContext(PatternPartContext, 0)
-}
-
-MergeClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-MergeClauseContext.prototype.mergeAction = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(MergeActionContext)
-  } else {
-    return this.getTypedRuleContext(MergeActionContext, i)
-  }
-}
-
-MergeClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterMergeClause(this)
-  }
-}
-
-MergeClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitMergeClause(this)
-  }
-}
-
-CypherParser.MergeClauseContext = MergeClauseContext
-
-CypherParser.prototype.mergeClause = function() {
-  var localctx = new MergeClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 138, CypherParser.RULE_mergeClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1102
-    this.match(CypherParser.MERGE)
-    this.state = 1104
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1103
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1106
-    this.patternPart()
-    this.state = 1111
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 106, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1107
-        this.match(CypherParser.SP)
-        this.state = 1108
-        this.mergeAction()
-      }
-      this.state = 1113
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 106, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function MergeActionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_mergeAction
-  return this
-}
-
-MergeActionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-MergeActionContext.prototype.constructor = MergeActionContext
-
-MergeActionContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-MergeActionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-MergeActionContext.prototype.MATCH = function() {
-  return this.getToken(CypherParser.MATCH, 0)
-}
-
-MergeActionContext.prototype.setClause = function() {
-  return this.getTypedRuleContext(SetClauseContext, 0)
-}
-
-MergeActionContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-MergeActionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterMergeAction(this)
-  }
-}
-
-MergeActionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitMergeAction(this)
-  }
-}
-
-CypherParser.MergeActionContext = MergeActionContext
-
-CypherParser.prototype.mergeAction = function() {
-  var localctx = new MergeActionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 140, CypherParser.RULE_mergeAction)
-  try {
-    this.state = 1124
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 107, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1114
-        this.match(CypherParser.ON)
-        this.state = 1115
-        this.match(CypherParser.SP)
-        this.state = 1116
-        this.match(CypherParser.MATCH)
-        this.state = 1117
-        this.match(CypherParser.SP)
-        this.state = 1118
-        this.setClause()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1119
-        this.match(CypherParser.ON)
-        this.state = 1120
-        this.match(CypherParser.SP)
-        this.state = 1121
-        this.match(CypherParser.CREATE)
-        this.state = 1122
-        this.match(CypherParser.SP)
-        this.state = 1123
-        this.setClause()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CreateClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_createClause
-  return this
-}
-
-CreateClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CreateClauseContext.prototype.constructor = CreateClauseContext
-
-CreateClauseContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-CreateClauseContext.prototype.pattern = function() {
-  return this.getTypedRuleContext(PatternContext, 0)
-}
-
-CreateClauseContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-CreateClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCreateClause(this)
-  }
-}
-
-CreateClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCreateClause(this)
-  }
-}
-
-CypherParser.CreateClauseContext = CreateClauseContext
-
-CypherParser.prototype.createClause = function() {
-  var localctx = new CreateClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 142, CypherParser.RULE_createClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1126
-    this.match(CypherParser.CREATE)
-    this.state = 1128
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1127
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1130
-    this.pattern()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CreateUniqueClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_createUniqueClause
-  return this
-}
-
-CreateUniqueClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CreateUniqueClauseContext.prototype.constructor = CreateUniqueClauseContext
-
-CreateUniqueClauseContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-CreateUniqueClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-CreateUniqueClauseContext.prototype.UNIQUE = function() {
-  return this.getToken(CypherParser.UNIQUE, 0)
-}
-
-CreateUniqueClauseContext.prototype.pattern = function() {
-  return this.getTypedRuleContext(PatternContext, 0)
-}
-
-CreateUniqueClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCreateUniqueClause(this)
-  }
-}
-
-CreateUniqueClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCreateUniqueClause(this)
-  }
-}
-
-CypherParser.CreateUniqueClauseContext = CreateUniqueClauseContext
-
-CypherParser.prototype.createUniqueClause = function() {
-  var localctx = new CreateUniqueClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 144, CypherParser.RULE_createUniqueClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1132
-    this.match(CypherParser.CREATE)
-    this.state = 1133
-    this.match(CypherParser.SP)
-    this.state = 1134
-    this.match(CypherParser.UNIQUE)
-    this.state = 1136
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1135
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1138
-    this.pattern()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SetClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_setClause
-  return this
-}
-
-SetClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SetClauseContext.prototype.constructor = SetClauseContext
-
-SetClauseContext.prototype.SET = function() {
-  return this.getToken(CypherParser.SET, 0)
-}
-
-SetClauseContext.prototype.setItem = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SetItemContext)
-  } else {
-    return this.getTypedRuleContext(SetItemContext, i)
-  }
-}
-
-SetClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-SetClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSetClause(this)
-  }
-}
-
-SetClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSetClause(this)
-  }
-}
-
-CypherParser.SetClauseContext = SetClauseContext
-
-CypherParser.prototype.setClause = function() {
-  var localctx = new SetClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 146, CypherParser.RULE_setClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1140
-    this.match(CypherParser.SET)
-    this.state = 1142
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1141
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1144
-    this.setItem()
-    this.state = 1155
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 113, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1146
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1145
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1148
-        this.match(CypherParser.T__14)
-        this.state = 1150
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1149
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1152
-        this.setItem()
-      }
-      this.state = 1157
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 113, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SetItemContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_setItem
-  return this
-}
-
-SetItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SetItemContext.prototype.constructor = SetItemContext
-
-SetItemContext.prototype.propertyExpression = function() {
-  return this.getTypedRuleContext(PropertyExpressionContext, 0)
-}
-
-SetItemContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-SetItemContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-SetItemContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-SetItemContext.prototype.nodeLabels = function() {
-  return this.getTypedRuleContext(NodeLabelsContext, 0)
-}
-
-SetItemContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSetItem(this)
-  }
-}
-
-SetItemContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSetItem(this)
-  }
-}
-
-CypherParser.SetItemContext = SetItemContext
-
-CypherParser.prototype.setItem = function() {
-  var localctx = new SetItemContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 148, CypherParser.RULE_setItem)
-  var _la = 0 // Token type
-  try {
-    this.state = 1194
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 121, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1158
-        this.propertyExpression()
-        this.state = 1160
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1159
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1162
-        this.match(CypherParser.T__11)
-        this.state = 1164
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1163
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1166
-        this.expression()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1168
-        this.variable()
-        this.state = 1170
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1169
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1172
-        this.match(CypherParser.T__11)
-        this.state = 1174
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1173
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1176
-        this.expression()
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 1178
-        this.variable()
-        this.state = 1180
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1179
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1182
-        this.match(CypherParser.T__20)
-        this.state = 1184
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1183
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1186
-        this.expression()
-        break
-
-      case 4:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 1188
-        this.variable()
-        this.state = 1190
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1189
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1192
-        this.nodeLabels()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DeleteClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_deleteClause
-  return this
-}
-
-DeleteClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-DeleteClauseContext.prototype.constructor = DeleteClauseContext
-
-DeleteClauseContext.prototype.DELETE = function() {
-  return this.getToken(CypherParser.DELETE, 0)
-}
-
-DeleteClauseContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-DeleteClauseContext.prototype.DETACH = function() {
-  return this.getToken(CypherParser.DETACH, 0)
-}
-
-DeleteClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-DeleteClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterDeleteClause(this)
-  }
-}
-
-DeleteClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitDeleteClause(this)
-  }
-}
-
-CypherParser.DeleteClauseContext = DeleteClauseContext
-
-CypherParser.prototype.deleteClause = function() {
-  var localctx = new DeleteClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 150, CypherParser.RULE_deleteClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1198
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.DETACH) {
-      this.state = 1196
-      this.match(CypherParser.DETACH)
-      this.state = 1197
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1200
-    this.match(CypherParser.DELETE)
-    this.state = 1202
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1201
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1204
-    this.expression()
-    this.state = 1215
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 126, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1206
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1205
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1208
-        this.match(CypherParser.T__14)
-        this.state = 1210
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1209
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1212
-        this.expression()
-      }
-      this.state = 1217
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 126, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RemoveClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_removeClause
-  return this
-}
-
-RemoveClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RemoveClauseContext.prototype.constructor = RemoveClauseContext
-
-RemoveClauseContext.prototype.REMOVE = function() {
-  return this.getToken(CypherParser.REMOVE, 0)
-}
-
-RemoveClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RemoveClauseContext.prototype.removeItem = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(RemoveItemContext)
-  } else {
-    return this.getTypedRuleContext(RemoveItemContext, i)
-  }
-}
-
-RemoveClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRemoveClause(this)
-  }
-}
-
-RemoveClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRemoveClause(this)
-  }
-}
-
-CypherParser.RemoveClauseContext = RemoveClauseContext
-
-CypherParser.prototype.removeClause = function() {
-  var localctx = new RemoveClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 152, CypherParser.RULE_removeClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1218
-    this.match(CypherParser.REMOVE)
-    this.state = 1219
-    this.match(CypherParser.SP)
-    this.state = 1220
-    this.removeItem()
-    this.state = 1231
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 129, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1222
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1221
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1224
-        this.match(CypherParser.T__14)
-        this.state = 1226
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1225
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1228
-        this.removeItem()
-      }
-      this.state = 1233
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 129, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RemoveItemContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_removeItem
-  return this
-}
-
-RemoveItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-RemoveItemContext.prototype.constructor = RemoveItemContext
-
-RemoveItemContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-RemoveItemContext.prototype.nodeLabels = function() {
-  return this.getTypedRuleContext(NodeLabelsContext, 0)
-}
-
-RemoveItemContext.prototype.propertyExpression = function() {
-  return this.getTypedRuleContext(PropertyExpressionContext, 0)
-}
-
-RemoveItemContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRemoveItem(this)
-  }
-}
-
-RemoveItemContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRemoveItem(this)
-  }
-}
-
-CypherParser.RemoveItemContext = RemoveItemContext
-
-CypherParser.prototype.removeItem = function() {
-  var localctx = new RemoveItemContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 154, CypherParser.RULE_removeItem)
-  try {
-    this.state = 1238
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 130, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1234
-        this.variable()
-        this.state = 1235
-        this.nodeLabels()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1237
-        this.propertyExpression()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ForeachClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_foreachClause
-  return this
-}
-
-ForeachClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ForeachClauseContext.prototype.constructor = ForeachClauseContext
-
-ForeachClauseContext.prototype.FOREACH = function() {
-  return this.getToken(CypherParser.FOREACH, 0)
-}
-
-ForeachClauseContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-ForeachClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ForeachClauseContext.prototype.IN = function() {
-  return this.getToken(CypherParser.IN, 0)
-}
-
-ForeachClauseContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-ForeachClauseContext.prototype.clause = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ClauseContext)
-  } else {
-    return this.getTypedRuleContext(ClauseContext, i)
-  }
-}
-
-ForeachClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterForeachClause(this)
-  }
-}
-
-ForeachClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitForeachClause(this)
-  }
-}
-
-CypherParser.ForeachClauseContext = ForeachClauseContext
-
-CypherParser.prototype.foreachClause = function() {
-  var localctx = new ForeachClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 156, CypherParser.RULE_foreachClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1240
-    this.match(CypherParser.FOREACH)
-    this.state = 1242
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1241
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1244
-    this.match(CypherParser.T__18)
-    this.state = 1246
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1245
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1248
-    this.variable()
-    this.state = 1249
-    this.match(CypherParser.SP)
-    this.state = 1250
-    this.match(CypherParser.IN)
-    this.state = 1251
-    this.match(CypherParser.SP)
-    this.state = 1252
-    this.expression()
-    this.state = 1254
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1253
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1256
-    this.match(CypherParser.T__21)
-    this.state = 1259
-    this._errHandler.sync(this)
-    var _alt = 1
-    do {
-      switch (_alt) {
-        case 1:
-          this.state = 1257
-          this.match(CypherParser.SP)
-          this.state = 1258
-          this.clause()
-          break
-        default:
-          throw new antlr4.error.NoViableAltException(this)
-      }
-      this.state = 1261
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 134, this._ctx)
-    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
-    this.state = 1264
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1263
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1266
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function WithClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_withClause
-  return this
-}
-
-WithClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-WithClauseContext.prototype.constructor = WithClauseContext
-
-WithClauseContext.prototype.WITH = function() {
-  return this.getToken(CypherParser.WITH, 0)
-}
-
-WithClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-WithClauseContext.prototype.returnBody = function() {
-  return this.getTypedRuleContext(ReturnBodyContext, 0)
-}
-
-WithClauseContext.prototype.DISTINCT = function() {
-  return this.getToken(CypherParser.DISTINCT, 0)
-}
-
-WithClauseContext.prototype.where = function() {
-  return this.getTypedRuleContext(WhereContext, 0)
-}
-
-WithClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterWithClause(this)
-  }
-}
-
-WithClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitWithClause(this)
-  }
-}
-
-CypherParser.WithClauseContext = WithClauseContext
-
-CypherParser.prototype.withClause = function() {
-  var localctx = new WithClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 158, CypherParser.RULE_withClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1268
-    this.match(CypherParser.WITH)
-    this.state = 1273
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 137, this._ctx)
-    if (la_ === 1) {
-      this.state = 1270
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1269
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1272
-      this.match(CypherParser.DISTINCT)
-    }
-    this.state = 1275
-    this.match(CypherParser.SP)
-    this.state = 1276
-    this.returnBody()
-    this.state = 1281
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 139, this._ctx)
-    if (la_ === 1) {
-      this.state = 1278
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1277
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1280
-      this.where()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ReturnClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_returnClause
-  return this
-}
-
-ReturnClauseContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ReturnClauseContext.prototype.constructor = ReturnClauseContext
-
-ReturnClauseContext.prototype.RETURN = function() {
-  return this.getToken(CypherParser.RETURN, 0)
-}
-
-ReturnClauseContext.prototype.returnBody = function() {
-  return this.getTypedRuleContext(ReturnBodyContext, 0)
-}
-
-ReturnClauseContext.prototype.DISTINCT = function() {
-  return this.getToken(CypherParser.DISTINCT, 0)
-}
-
-ReturnClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ReturnClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterReturnClause(this)
-  }
-}
-
-ReturnClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitReturnClause(this)
-  }
-}
-
-CypherParser.ReturnClauseContext = ReturnClauseContext
-
-CypherParser.prototype.returnClause = function() {
-  var localctx = new ReturnClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 160, CypherParser.RULE_returnClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1283
-    this.match(CypherParser.RETURN)
-    this.state = 1288
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 141, this._ctx)
-    if (la_ === 1) {
-      this.state = 1285
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1284
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1287
-      this.match(CypherParser.DISTINCT)
-    }
-    this.state = 1291
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1290
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1293
-    this.returnBody()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ReturnBodyContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_returnBody
-  return this
-}
-
-ReturnBodyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ReturnBodyContext.prototype.constructor = ReturnBodyContext
-
-ReturnBodyContext.prototype.returnItems = function() {
-  return this.getTypedRuleContext(ReturnItemsContext, 0)
-}
-
-ReturnBodyContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ReturnBodyContext.prototype.order = function() {
-  return this.getTypedRuleContext(OrderContext, 0)
-}
-
-ReturnBodyContext.prototype.skip = function() {
-  return this.getTypedRuleContext(SkipContext, 0)
-}
-
-ReturnBodyContext.prototype.limit = function() {
-  return this.getTypedRuleContext(LimitContext, 0)
-}
-
-ReturnBodyContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterReturnBody(this)
-  }
-}
-
-ReturnBodyContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitReturnBody(this)
-  }
-}
-
-CypherParser.ReturnBodyContext = ReturnBodyContext
-
-CypherParser.prototype.returnBody = function() {
-  var localctx = new ReturnBodyContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 162, CypherParser.RULE_returnBody)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1295
-    this.returnItems()
-    this.state = 1298
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 143, this._ctx)
-    if (la_ === 1) {
-      this.state = 1296
-      this.match(CypherParser.SP)
-      this.state = 1297
-      this.order()
-    }
-    this.state = 1302
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 144, this._ctx)
-    if (la_ === 1) {
-      this.state = 1300
-      this.match(CypherParser.SP)
-      this.state = 1301
-      this.skip()
-    }
-    this.state = 1306
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 145, this._ctx)
-    if (la_ === 1) {
-      this.state = 1304
-      this.match(CypherParser.SP)
-      this.state = 1305
-      this.limit()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ReturnItemsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_returnItems
-  return this
-}
-
-ReturnItemsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ReturnItemsContext.prototype.constructor = ReturnItemsContext
-
-ReturnItemsContext.prototype.returnItem = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ReturnItemContext)
-  } else {
-    return this.getTypedRuleContext(ReturnItemContext, i)
-  }
-}
-
-ReturnItemsContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ReturnItemsContext.prototype.procedureInvocation = function() {
-  return this.getTypedRuleContext(ProcedureInvocationContext, 0)
-}
-
-ReturnItemsContext.prototype.procedureResults = function() {
-  return this.getTypedRuleContext(ProcedureResultsContext, 0)
-}
-
-ReturnItemsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterReturnItems(this)
-  }
-}
-
-ReturnItemsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitReturnItems(this)
-  }
-}
-
-CypherParser.ReturnItemsContext = ReturnItemsContext
-
-CypherParser.prototype.returnItems = function() {
-  var localctx = new ReturnItemsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 164, CypherParser.RULE_returnItems)
-  var _la = 0 // Token type
-  try {
-    this.state = 1343
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 154, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1308
-        this.match(CypherParser.T__22)
-        this.state = 1319
-        this._errHandler.sync(this)
-        var _alt = this._interp.adaptivePredict(this._input, 148, this._ctx)
-        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-          if (_alt === 1) {
-            this.state = 1310
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1309
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1312
-            this.match(CypherParser.T__14)
-            this.state = 1314
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1313
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1316
-            this.returnItem()
-          }
-          this.state = 1321
-          this._errHandler.sync(this)
-          _alt = this._interp.adaptivePredict(this._input, 148, this._ctx)
-        }
-
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1322
-        this.returnItem()
-        this.state = 1333
-        this._errHandler.sync(this)
-        var _alt = this._interp.adaptivePredict(this._input, 151, this._ctx)
-        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-          if (_alt === 1) {
-            this.state = 1324
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1323
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1326
-            this.match(CypherParser.T__14)
-            this.state = 1328
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1327
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1330
-            this.returnItem()
-          }
-          this.state = 1335
-          this._errHandler.sync(this)
-          _alt = this._interp.adaptivePredict(this._input, 151, this._ctx)
-        }
-
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 1336
-        this.procedureInvocation()
-        this.state = 1338
-        this._errHandler.sync(this)
-        var la_ = this._interp.adaptivePredict(this._input, 152, this._ctx)
-        if (la_ === 1) {
-          this.state = 1337
-          this.match(CypherParser.SP)
-        }
-        this.state = 1341
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.YIELD) {
-          this.state = 1340
-          this.procedureResults()
-        }
-
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ReturnItemContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_returnItem
-  return this
-}
-
-ReturnItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ReturnItemContext.prototype.constructor = ReturnItemContext
-
-ReturnItemContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-ReturnItemContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ReturnItemContext.prototype.AS = function() {
-  return this.getToken(CypherParser.AS, 0)
-}
-
-ReturnItemContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-ReturnItemContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterReturnItem(this)
-  }
-}
-
-ReturnItemContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitReturnItem(this)
-  }
-}
-
-CypherParser.ReturnItemContext = ReturnItemContext
-
-CypherParser.prototype.returnItem = function() {
-  var localctx = new ReturnItemContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 166, CypherParser.RULE_returnItem)
-  try {
-    this.state = 1352
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 155, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1345
-        this.expression()
-        this.state = 1346
-        this.match(CypherParser.SP)
-        this.state = 1347
-        this.match(CypherParser.AS)
-        this.state = 1348
-        this.match(CypherParser.SP)
-        this.state = 1349
-        this.variable()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1351
-        this.expression()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CallContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_call
-  return this
-}
-
-CallContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-CallContext.prototype.constructor = CallContext
-
-CallContext.prototype.CALL = function() {
-  return this.getToken(CypherParser.CALL, 0)
-}
-
-CallContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-CallContext.prototype.procedureInvocation = function() {
-  return this.getTypedRuleContext(ProcedureInvocationContext, 0)
-}
-
-CallContext.prototype.procedureResults = function() {
-  return this.getTypedRuleContext(ProcedureResultsContext, 0)
-}
-
-CallContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCall(this)
-  }
-}
-
-CallContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCall(this)
-  }
-}
-
-CypherParser.CallContext = CallContext
-
-CypherParser.prototype.call = function() {
-  var localctx = new CallContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 168, CypherParser.RULE_call)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1354
-    this.match(CypherParser.CALL)
-    this.state = 1355
-    this.match(CypherParser.SP)
-    this.state = 1356
-    this.procedureInvocation()
-    this.state = 1358
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 156, this._ctx)
-    if (la_ === 1) {
-      this.state = 1357
-      this.match(CypherParser.SP)
-    }
-    this.state = 1361
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.YIELD) {
-      this.state = 1360
-      this.procedureResults()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProcedureInvocationContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_procedureInvocation
-  return this
-}
-
-ProcedureInvocationContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ProcedureInvocationContext.prototype.constructor = ProcedureInvocationContext
-
-ProcedureInvocationContext.prototype.procedureInvocationBody = function() {
-  return this.getTypedRuleContext(ProcedureInvocationBodyContext, 0)
-}
-
-ProcedureInvocationContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-ProcedureInvocationContext.prototype.procedureArguments = function() {
-  return this.getTypedRuleContext(ProcedureArgumentsContext, 0)
-}
-
-ProcedureInvocationContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProcedureInvocation(this)
-  }
-}
-
-ProcedureInvocationContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProcedureInvocation(this)
-  }
-}
-
-CypherParser.ProcedureInvocationContext = ProcedureInvocationContext
-
-CypherParser.prototype.procedureInvocation = function() {
-  var localctx = new ProcedureInvocationContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 170, CypherParser.RULE_procedureInvocation)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1363
-    this.procedureInvocationBody()
-    this.state = 1365
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 158, this._ctx)
-    if (la_ === 1) {
-      this.state = 1364
-      this.match(CypherParser.SP)
-    }
-    this.state = 1368
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__18) {
-      this.state = 1367
-      this.procedureArguments()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProcedureInvocationBodyContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_procedureInvocationBody
-  return this
-}
-
-ProcedureInvocationBodyContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ProcedureInvocationBodyContext.prototype.constructor = ProcedureInvocationBodyContext
-
-ProcedureInvocationBodyContext.prototype.namespace = function() {
-  return this.getTypedRuleContext(NamespaceContext, 0)
-}
-
-ProcedureInvocationBodyContext.prototype.procedureName = function() {
-  return this.getTypedRuleContext(ProcedureNameContext, 0)
-}
-
-ProcedureInvocationBodyContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProcedureInvocationBody(this)
-  }
-}
-
-ProcedureInvocationBodyContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProcedureInvocationBody(this)
-  }
-}
-
-CypherParser.ProcedureInvocationBodyContext = ProcedureInvocationBodyContext
-
-CypherParser.prototype.procedureInvocationBody = function() {
-  var localctx = new ProcedureInvocationBodyContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 172, CypherParser.RULE_procedureInvocationBody)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1370
-    this.namespace()
-    this.state = 1371
-    this.procedureName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProcedureArgumentsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_procedureArguments
-  return this
-}
-
-ProcedureArgumentsContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ProcedureArgumentsContext.prototype.constructor = ProcedureArgumentsContext
-
-ProcedureArgumentsContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ProcedureArgumentsContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-ProcedureArgumentsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProcedureArguments(this)
-  }
-}
-
-ProcedureArgumentsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProcedureArguments(this)
-  }
-}
-
-CypherParser.ProcedureArgumentsContext = ProcedureArgumentsContext
-
-CypherParser.prototype.procedureArguments = function() {
-  var localctx = new ProcedureArgumentsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 174, CypherParser.RULE_procedureArguments)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1373
-    this.match(CypherParser.T__18)
-    this.state = 1375
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 160, this._ctx)
-    if (la_ === 1) {
-      this.state = 1374
-      this.match(CypherParser.SP)
-    }
-    this.state = 1378
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      ((_la & ~0x1f) == 0 &&
-        ((1 << _la) &
-          ((1 << CypherParser.T__2) |
-            (1 << CypherParser.T__12) |
-            (1 << CypherParser.T__13) |
-            (1 << CypherParser.T__16) |
-            (1 << CypherParser.T__18))) !==
-          0) ||
-      (((_la - 34) & ~0x1f) == 0 &&
-        ((1 << (_la - 34)) &
-          ((1 << (CypherParser.T__33 - 34)) |
-            (1 << (CypherParser.CYPHER - 34)) |
-            (1 << (CypherParser.EXPLAIN - 34)) |
-            (1 << (CypherParser.PROFILE - 34)) |
-            (1 << (CypherParser.USING - 34)) |
-            (1 << (CypherParser.PERIODIC - 34)) |
-            (1 << (CypherParser.COMMIT - 34)) |
-            (1 << (CypherParser.UNION - 34)) |
-            (1 << (CypherParser.ALL - 34)) |
-            (1 << (CypherParser.CREATE - 34)) |
-            (1 << (CypherParser.DROP - 34)) |
-            (1 << (CypherParser.INDEX - 34)) |
-            (1 << (CypherParser.ON - 34)))) !==
-          0) ||
-      (((_la - 66) & ~0x1f) == 0 &&
-        ((1 << (_la - 66)) &
-          ((1 << (CypherParser.CONSTRAINT - 66)) |
-            (1 << (CypherParser.ASSERT - 66)) |
-            (1 << (CypherParser.IS - 66)) |
-            (1 << (CypherParser.UNIQUE - 66)) |
-            (1 << (CypherParser.EXISTS - 66)) |
-            (1 << (CypherParser.LOAD - 66)) |
-            (1 << (CypherParser.CSV - 66)) |
-            (1 << (CypherParser.WITH - 66)) |
-            (1 << (CypherParser.HEADERS - 66)) |
-            (1 << (CypherParser.FROM - 66)) |
-            (1 << (CypherParser.AS - 66)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 66)) |
-            (1 << (CypherParser.OPTIONAL - 66)) |
-            (1 << (CypherParser.MATCH - 66)) |
-            (1 << (CypherParser.UNWIND - 66)) |
-            (1 << (CypherParser.MERGE - 66)) |
-            (1 << (CypherParser.SET - 66)) |
-            (1 << (CypherParser.DETACH - 66)) |
-            (1 << (CypherParser.DELETE - 66)) |
-            (1 << (CypherParser.REMOVE - 66)) |
-            (1 << (CypherParser.FOREACH - 66)) |
-            (1 << (CypherParser.IN - 66)) |
-            (1 << (CypherParser.DISTINCT - 66)) |
-            (1 << (CypherParser.RETURN - 66)) |
-            (1 << (CypherParser.ORDER - 66)) |
-            (1 << (CypherParser.BY - 66)) |
-            (1 << (CypherParser.L_SKIP - 66)) |
-            (1 << (CypherParser.LIMIT - 66)) |
-            (1 << (CypherParser.ASCENDING - 66)) |
-            (1 << (CypherParser.ASC - 66)) |
-            (1 << (CypherParser.DESCENDING - 66)) |
-            (1 << (CypherParser.DESC - 66)))) !==
-          0) ||
-      (((_la - 98) & ~0x1f) == 0 &&
-        ((1 << (_la - 98)) &
-          ((1 << (CypherParser.JOIN - 98)) |
-            (1 << (CypherParser.SCAN - 98)) |
-            (1 << (CypherParser.START - 98)) |
-            (1 << (CypherParser.NODE - 98)) |
-            (1 << (CypherParser.RELATIONSHIP - 98)) |
-            (1 << (CypherParser.REL - 98)) |
-            (1 << (CypherParser.WHERE - 98)) |
-            (1 << (CypherParser.SHORTESTPATH - 98)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
-            (1 << (CypherParser.OR - 98)) |
-            (1 << (CypherParser.XOR - 98)) |
-            (1 << (CypherParser.AND - 98)) |
-            (1 << (CypherParser.NOT - 98)) |
-            (1 << (CypherParser.STARTS - 98)) |
-            (1 << (CypherParser.ENDS - 98)) |
-            (1 << (CypherParser.CONTAINS - 98)) |
-            (1 << (CypherParser.NULL - 98)) |
-            (1 << (CypherParser.COUNT - 98)) |
-            (1 << (CypherParser.FILTER - 98)) |
-            (1 << (CypherParser.EXTRACT - 98)) |
-            (1 << (CypherParser.ANY - 98)) |
-            (1 << (CypherParser.NONE - 98)) |
-            (1 << (CypherParser.SINGLE - 98)) |
-            (1 << (CypherParser.TRUE - 98)) |
-            (1 << (CypherParser.FALSE - 98)) |
-            (1 << (CypherParser.REDUCE - 98)) |
-            (1 << (CypherParser.CASE - 98)) |
-            (1 << (CypherParser.ELSE - 98)) |
-            (1 << (CypherParser.END - 98)) |
-            (1 << (CypherParser.WHEN - 98)) |
-            (1 << (CypherParser.THEN - 98)) |
-            (1 << (CypherParser.CALL - 98)))) !==
-          0) ||
-      (((_la - 130) & ~0x1f) == 0 &&
-        ((1 << (_la - 130)) &
-          ((1 << (CypherParser.YIELD - 130)) |
-            (1 << (CypherParser.KEY - 130)) |
-            (1 << (CypherParser.StringLiteral - 130)) |
-            (1 << (CypherParser.HexInteger - 130)) |
-            (1 << (CypherParser.DecimalInteger - 130)) |
-            (1 << (CypherParser.OctalInteger - 130)) |
-            (1 << (CypherParser.HexLetter - 130)) |
-            (1 << (CypherParser.ExponentDecimalReal - 130)) |
-            (1 << (CypherParser.RegularDecimalReal - 130)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 130)) |
-            (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
-          0)
-    ) {
-      this.state = 1377
-      this.expression()
-    }
-
-    this.state = 1390
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 164, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1381
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1380
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1383
-        this.match(CypherParser.T__14)
-        this.state = 1385
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1384
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1387
-        this.expression()
-      }
-      this.state = 1392
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 164, this._ctx)
-    }
-
-    this.state = 1394
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1393
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1396
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProcedureResultsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_procedureResults
-  return this
-}
-
-ProcedureResultsContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ProcedureResultsContext.prototype.constructor = ProcedureResultsContext
-
-ProcedureResultsContext.prototype.YIELD = function() {
-  return this.getToken(CypherParser.YIELD, 0)
-}
-
-ProcedureResultsContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ProcedureResultsContext.prototype.procedureResult = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ProcedureResultContext)
-  } else {
-    return this.getTypedRuleContext(ProcedureResultContext, i)
-  }
-}
-
-ProcedureResultsContext.prototype.where = function() {
-  return this.getTypedRuleContext(WhereContext, 0)
-}
-
-ProcedureResultsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProcedureResults(this)
-  }
-}
-
-ProcedureResultsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProcedureResults(this)
-  }
-}
-
-CypherParser.ProcedureResultsContext = ProcedureResultsContext
-
-CypherParser.prototype.procedureResults = function() {
-  var localctx = new ProcedureResultsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 176, CypherParser.RULE_procedureResults)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1398
-    this.match(CypherParser.YIELD)
-    this.state = 1399
-    this.match(CypherParser.SP)
-    this.state = 1400
-    this.procedureResult()
-    this.state = 1411
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 168, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1402
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1401
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1404
-        this.match(CypherParser.T__14)
-        this.state = 1406
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1405
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1408
-        this.procedureResult()
-      }
-      this.state = 1413
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 168, this._ctx)
-    }
-
-    this.state = 1416
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 169, this._ctx)
-    if (la_ === 1) {
-      this.state = 1414
-      this.match(CypherParser.SP)
-      this.state = 1415
-      this.where()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProcedureResultContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_procedureResult
-  return this
-}
-
-ProcedureResultContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ProcedureResultContext.prototype.constructor = ProcedureResultContext
-
-ProcedureResultContext.prototype.aliasedProcedureResult = function() {
-  return this.getTypedRuleContext(AliasedProcedureResultContext, 0)
-}
-
-ProcedureResultContext.prototype.simpleProcedureResult = function() {
-  return this.getTypedRuleContext(SimpleProcedureResultContext, 0)
-}
-
-ProcedureResultContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProcedureResult(this)
-  }
-}
-
-ProcedureResultContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProcedureResult(this)
-  }
-}
-
-CypherParser.ProcedureResultContext = ProcedureResultContext
-
-CypherParser.prototype.procedureResult = function() {
-  var localctx = new ProcedureResultContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 178, CypherParser.RULE_procedureResult)
-  try {
-    this.state = 1420
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 170, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1418
-        this.aliasedProcedureResult()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1419
-        this.simpleProcedureResult()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AliasedProcedureResultContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_aliasedProcedureResult
-  return this
-}
-
-AliasedProcedureResultContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AliasedProcedureResultContext.prototype.constructor = AliasedProcedureResultContext
-
-AliasedProcedureResultContext.prototype.procedureOutput = function() {
-  return this.getTypedRuleContext(ProcedureOutputContext, 0)
-}
-
-AliasedProcedureResultContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-AliasedProcedureResultContext.prototype.AS = function() {
-  return this.getToken(CypherParser.AS, 0)
-}
-
-AliasedProcedureResultContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-AliasedProcedureResultContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAliasedProcedureResult(this)
-  }
-}
-
-AliasedProcedureResultContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAliasedProcedureResult(this)
-  }
-}
-
-CypherParser.AliasedProcedureResultContext = AliasedProcedureResultContext
-
-CypherParser.prototype.aliasedProcedureResult = function() {
-  var localctx = new AliasedProcedureResultContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 180, CypherParser.RULE_aliasedProcedureResult)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1422
-    this.procedureOutput()
-    this.state = 1423
-    this.match(CypherParser.SP)
-    this.state = 1424
-    this.match(CypherParser.AS)
-    this.state = 1425
-    this.match(CypherParser.SP)
-    this.state = 1426
-    this.variable()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SimpleProcedureResultContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_simpleProcedureResult
-  return this
-}
-
-SimpleProcedureResultContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-SimpleProcedureResultContext.prototype.constructor = SimpleProcedureResultContext
-
-SimpleProcedureResultContext.prototype.procedureOutput = function() {
-  return this.getTypedRuleContext(ProcedureOutputContext, 0)
-}
-
-SimpleProcedureResultContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSimpleProcedureResult(this)
-  }
-}
-
-SimpleProcedureResultContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSimpleProcedureResult(this)
-  }
-}
-
-CypherParser.SimpleProcedureResultContext = SimpleProcedureResultContext
-
-CypherParser.prototype.simpleProcedureResult = function() {
-  var localctx = new SimpleProcedureResultContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 182, CypherParser.RULE_simpleProcedureResult)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1428
-    this.procedureOutput()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProcedureOutputContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_procedureOutput
-  return this
-}
-
-ProcedureOutputContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ProcedureOutputContext.prototype.constructor = ProcedureOutputContext
-
-ProcedureOutputContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-ProcedureOutputContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProcedureOutput(this)
-  }
-}
-
-ProcedureOutputContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProcedureOutput(this)
-  }
-}
-
-CypherParser.ProcedureOutputContext = ProcedureOutputContext
-
-CypherParser.prototype.procedureOutput = function() {
-  var localctx = new ProcedureOutputContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 184, CypherParser.RULE_procedureOutput)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1430
-    this.symbolicName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function OrderContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_order
-  return this
-}
-
-OrderContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-OrderContext.prototype.constructor = OrderContext
-
-OrderContext.prototype.ORDER = function() {
-  return this.getToken(CypherParser.ORDER, 0)
-}
-
-OrderContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-OrderContext.prototype.BY = function() {
-  return this.getToken(CypherParser.BY, 0)
-}
-
-OrderContext.prototype.sortItem = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SortItemContext)
-  } else {
-    return this.getTypedRuleContext(SortItemContext, i)
-  }
-}
-
-OrderContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterOrder(this)
-  }
-}
-
-OrderContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitOrder(this)
-  }
-}
-
-CypherParser.OrderContext = OrderContext
-
-CypherParser.prototype.order = function() {
-  var localctx = new OrderContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 186, CypherParser.RULE_order)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1432
-    this.match(CypherParser.ORDER)
-    this.state = 1433
-    this.match(CypherParser.SP)
-    this.state = 1434
-    this.match(CypherParser.BY)
-    this.state = 1435
-    this.match(CypherParser.SP)
-    this.state = 1436
-    this.sortItem()
-    this.state = 1447
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 173, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1438
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1437
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1440
-        this.match(CypherParser.T__14)
-        this.state = 1442
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1441
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1444
-        this.sortItem()
-      }
-      this.state = 1449
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 173, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SkipContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_skip
-  return this
-}
-
-SkipContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SkipContext.prototype.constructor = SkipContext
-
-SkipContext.prototype.L_SKIP = function() {
-  return this.getToken(CypherParser.L_SKIP, 0)
-}
-
-SkipContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-SkipContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-SkipContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSkip(this)
-  }
-}
-
-SkipContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSkip(this)
-  }
-}
-
-CypherParser.SkipContext = SkipContext
-
-CypherParser.prototype.skip = function() {
-  var localctx = new SkipContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 188, CypherParser.RULE_skip)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1450
-    this.match(CypherParser.L_SKIP)
-    this.state = 1451
-    this.match(CypherParser.SP)
-    this.state = 1452
-    this.expression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LimitContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_limit
-  return this
-}
-
-LimitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-LimitContext.prototype.constructor = LimitContext
-
-LimitContext.prototype.LIMIT = function() {
-  return this.getToken(CypherParser.LIMIT, 0)
-}
-
-LimitContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-LimitContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-LimitContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLimit(this)
-  }
-}
-
-LimitContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLimit(this)
-  }
-}
-
-CypherParser.LimitContext = LimitContext
-
-CypherParser.prototype.limit = function() {
-  var localctx = new LimitContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 190, CypherParser.RULE_limit)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1454
-    this.match(CypherParser.LIMIT)
-    this.state = 1455
-    this.match(CypherParser.SP)
-    this.state = 1456
-    this.expression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SortItemContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_sortItem
-  return this
-}
-
-SortItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-SortItemContext.prototype.constructor = SortItemContext
-
-SortItemContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-SortItemContext.prototype.ASCENDING = function() {
-  return this.getToken(CypherParser.ASCENDING, 0)
-}
-
-SortItemContext.prototype.ASC = function() {
-  return this.getToken(CypherParser.ASC, 0)
-}
-
-SortItemContext.prototype.DESCENDING = function() {
-  return this.getToken(CypherParser.DESCENDING, 0)
-}
-
-SortItemContext.prototype.DESC = function() {
-  return this.getToken(CypherParser.DESC, 0)
-}
-
-SortItemContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-SortItemContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSortItem(this)
-  }
-}
-
-SortItemContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSortItem(this)
-  }
-}
-
-CypherParser.SortItemContext = SortItemContext
-
-CypherParser.prototype.sortItem = function() {
-  var localctx = new SortItemContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 192, CypherParser.RULE_sortItem)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1458
-    this.expression()
-    this.state = 1466
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 176, this._ctx)
-    if (la_ === 1) {
-      this.state = 1460
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1459
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1462
-      _la = this._input.LA(1)
-      if (
-        !(
-          ((_la - 94) & ~0x1f) == 0 &&
-          ((1 << (_la - 94)) &
-            ((1 << (CypherParser.ASCENDING - 94)) |
-              (1 << (CypherParser.ASC - 94)) |
-              (1 << (CypherParser.DESCENDING - 94)) |
-              (1 << (CypherParser.DESC - 94)))) !==
-            0
-        )
-      ) {
-        this._errHandler.recoverInline(this)
-      } else {
-        this._errHandler.reportMatch(this)
-        this.consume()
-      }
-      this.state = 1464
-      this._errHandler.sync(this)
-      var la_ = this._interp.adaptivePredict(this._input, 175, this._ctx)
-      if (la_ === 1) {
-        this.state = 1463
-        this.match(CypherParser.SP)
-      }
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function HintContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_hint
-  return this
-}
-
-HintContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-HintContext.prototype.constructor = HintContext
-
-HintContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-HintContext.prototype.USING = function() {
-  return this.getToken(CypherParser.USING, 0)
-}
-
-HintContext.prototype.INDEX = function() {
-  return this.getToken(CypherParser.INDEX, 0)
-}
-
-HintContext.prototype.variable = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(VariableContext)
-  } else {
-    return this.getTypedRuleContext(VariableContext, i)
-  }
-}
-
-HintContext.prototype.nodeLabel = function() {
-  return this.getTypedRuleContext(NodeLabelContext, 0)
-}
-
-HintContext.prototype.propertyKeys = function() {
-  return this.getTypedRuleContext(PropertyKeysContext, 0)
-}
-
-HintContext.prototype.JOIN = function() {
-  return this.getToken(CypherParser.JOIN, 0)
-}
-
-HintContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-HintContext.prototype.SCAN = function() {
-  return this.getToken(CypherParser.SCAN, 0)
-}
-
-HintContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterHint(this)
-  }
-}
-
-HintContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitHint(this)
-  }
-}
-
-CypherParser.HintContext = HintContext
-
-CypherParser.prototype.hint = function() {
-  var localctx = new HintContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 194, CypherParser.RULE_hint)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1469
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1468
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1517
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 184, this._ctx)
-    switch (la_) {
-      case 1:
-        this.state = 1471
-        this.match(CypherParser.USING)
-        this.state = 1472
-        this.match(CypherParser.SP)
-        this.state = 1473
-        this.match(CypherParser.INDEX)
-        this.state = 1474
-        this.match(CypherParser.SP)
-        this.state = 1475
-        this.variable()
-        this.state = 1476
-        this.nodeLabel()
-        this.state = 1478
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1477
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1480
-        this.match(CypherParser.T__18)
-        this.state = 1482
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1481
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1484
-        this.propertyKeys()
-        this.state = 1486
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1485
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1488
-        this.match(CypherParser.T__19)
-        break
-
-      case 2:
-        this.state = 1490
-        this.match(CypherParser.USING)
-        this.state = 1491
-        this.match(CypherParser.SP)
-        this.state = 1492
-        this.match(CypherParser.JOIN)
-        this.state = 1493
-        this.match(CypherParser.SP)
-        this.state = 1494
-        this.match(CypherParser.ON)
-        this.state = 1495
-        this.match(CypherParser.SP)
-        this.state = 1496
-        this.variable()
-        this.state = 1507
-        this._errHandler.sync(this)
-        var _alt = this._interp.adaptivePredict(this._input, 183, this._ctx)
-        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-          if (_alt === 1) {
-            this.state = 1498
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1497
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1500
-            this.match(CypherParser.T__14)
-            this.state = 1502
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1501
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1504
-            this.variable()
-          }
-          this.state = 1509
-          this._errHandler.sync(this)
-          _alt = this._interp.adaptivePredict(this._input, 183, this._ctx)
-        }
-
-        break
-
-      case 3:
-        this.state = 1510
-        this.match(CypherParser.USING)
-        this.state = 1511
-        this.match(CypherParser.SP)
-        this.state = 1512
-        this.match(CypherParser.SCAN)
-        this.state = 1513
-        this.match(CypherParser.SP)
-        this.state = 1514
-        this.variable()
-        this.state = 1515
-        this.nodeLabel()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function StartClauseContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_startClause
-  return this
-}
-
-StartClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-StartClauseContext.prototype.constructor = StartClauseContext
-
-StartClauseContext.prototype.START = function() {
-  return this.getToken(CypherParser.START, 0)
-}
-
-StartClauseContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-StartClauseContext.prototype.startPoint = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(StartPointContext)
-  } else {
-    return this.getTypedRuleContext(StartPointContext, i)
-  }
-}
-
-StartClauseContext.prototype.where = function() {
-  return this.getTypedRuleContext(WhereContext, 0)
-}
-
-StartClauseContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterStartClause(this)
-  }
-}
-
-StartClauseContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitStartClause(this)
-  }
-}
-
-CypherParser.StartClauseContext = StartClauseContext
-
-CypherParser.prototype.startClause = function() {
-  var localctx = new StartClauseContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 196, CypherParser.RULE_startClause)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1519
-    this.match(CypherParser.START)
-    this.state = 1520
-    this.match(CypherParser.SP)
-    this.state = 1521
-    this.startPoint()
-    this.state = 1532
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 187, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1523
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1522
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1525
-        this.match(CypherParser.T__14)
-        this.state = 1527
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1526
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1529
-        this.startPoint()
-      }
-      this.state = 1534
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 187, this._ctx)
-    }
-
-    this.state = 1536
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.WHERE) {
-      this.state = 1535
-      this.where()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function StartPointContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_startPoint
-  return this
-}
-
-StartPointContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-StartPointContext.prototype.constructor = StartPointContext
-
-StartPointContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-StartPointContext.prototype.lookup = function() {
-  return this.getTypedRuleContext(LookupContext, 0)
-}
-
-StartPointContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-StartPointContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterStartPoint(this)
-  }
-}
-
-StartPointContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitStartPoint(this)
-  }
-}
-
-CypherParser.StartPointContext = StartPointContext
-
-CypherParser.prototype.startPoint = function() {
-  var localctx = new StartPointContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 198, CypherParser.RULE_startPoint)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1538
-    this.variable()
-    this.state = 1540
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1539
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1542
-    this.match(CypherParser.T__11)
-    this.state = 1544
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1543
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1546
-    this.lookup()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LookupContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_lookup
-  return this
-}
-
-LookupContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-LookupContext.prototype.constructor = LookupContext
-
-LookupContext.prototype.nodeLookup = function() {
-  return this.getTypedRuleContext(NodeLookupContext, 0)
-}
-
-LookupContext.prototype.relationshipLookup = function() {
-  return this.getTypedRuleContext(RelationshipLookupContext, 0)
-}
-
-LookupContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLookup(this)
-  }
-}
-
-LookupContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLookup(this)
-  }
-}
-
-CypherParser.LookupContext = LookupContext
-
-CypherParser.prototype.lookup = function() {
-  var localctx = new LookupContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 200, CypherParser.RULE_lookup)
-  try {
-    this.state = 1550
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.NODE:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1548
-        this.nodeLookup()
-        break
-      case CypherParser.RELATIONSHIP:
-      case CypherParser.REL:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1549
-        this.relationshipLookup()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NodeLookupContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_nodeLookup
-  return this
-}
-
-NodeLookupContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-NodeLookupContext.prototype.constructor = NodeLookupContext
-
-NodeLookupContext.prototype.NODE = function() {
-  return this.getToken(CypherParser.NODE, 0)
-}
-
-NodeLookupContext.prototype.identifiedIndexLookup = function() {
-  return this.getTypedRuleContext(IdentifiedIndexLookupContext, 0)
-}
-
-NodeLookupContext.prototype.indexQuery = function() {
-  return this.getTypedRuleContext(IndexQueryContext, 0)
-}
-
-NodeLookupContext.prototype.idLookup = function() {
-  return this.getTypedRuleContext(IdLookupContext, 0)
-}
-
-NodeLookupContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-NodeLookupContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNodeLookup(this)
-  }
-}
-
-NodeLookupContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNodeLookup(this)
-  }
-}
-
-CypherParser.NodeLookupContext = NodeLookupContext
-
-CypherParser.prototype.nodeLookup = function() {
-  var localctx = new NodeLookupContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 202, CypherParser.RULE_nodeLookup)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1552
-    this.match(CypherParser.NODE)
-    this.state = 1554
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1553
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1559
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 193, this._ctx)
-    switch (la_) {
-      case 1:
-        this.state = 1556
-        this.identifiedIndexLookup()
-        break
-
-      case 2:
-        this.state = 1557
-        this.indexQuery()
-        break
-
-      case 3:
-        this.state = 1558
-        this.idLookup()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipLookupContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipLookup
-  return this
-}
-
-RelationshipLookupContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipLookupContext.prototype.constructor = RelationshipLookupContext
-
-RelationshipLookupContext.prototype.RELATIONSHIP = function() {
-  return this.getToken(CypherParser.RELATIONSHIP, 0)
-}
-
-RelationshipLookupContext.prototype.REL = function() {
-  return this.getToken(CypherParser.REL, 0)
-}
-
-RelationshipLookupContext.prototype.identifiedIndexLookup = function() {
-  return this.getTypedRuleContext(IdentifiedIndexLookupContext, 0)
-}
-
-RelationshipLookupContext.prototype.indexQuery = function() {
-  return this.getTypedRuleContext(IndexQueryContext, 0)
-}
-
-RelationshipLookupContext.prototype.idLookup = function() {
-  return this.getTypedRuleContext(IdLookupContext, 0)
-}
-
-RelationshipLookupContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipLookup(this)
-  }
-}
-
-RelationshipLookupContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipLookup(this)
-  }
-}
-
-CypherParser.RelationshipLookupContext = RelationshipLookupContext
-
-CypherParser.prototype.relationshipLookup = function() {
-  var localctx = new RelationshipLookupContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 204, CypherParser.RULE_relationshipLookup)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1561
-    _la = this._input.LA(1)
-    if (!(_la === CypherParser.RELATIONSHIP || _la === CypherParser.REL)) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-    this.state = 1565
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 194, this._ctx)
-    switch (la_) {
-      case 1:
-        this.state = 1562
-        this.identifiedIndexLookup()
-        break
-
-      case 2:
-        this.state = 1563
-        this.indexQuery()
-        break
-
-      case 3:
-        this.state = 1564
-        this.idLookup()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function IdentifiedIndexLookupContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_identifiedIndexLookup
-  return this
-}
-
-IdentifiedIndexLookupContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-IdentifiedIndexLookupContext.prototype.constructor = IdentifiedIndexLookupContext
-
-IdentifiedIndexLookupContext.prototype.symbolicName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SymbolicNameContext)
-  } else {
-    return this.getTypedRuleContext(SymbolicNameContext, i)
-  }
-}
-
-IdentifiedIndexLookupContext.prototype.StringLiteral = function() {
-  return this.getToken(CypherParser.StringLiteral, 0)
-}
-
-IdentifiedIndexLookupContext.prototype.parameter = function() {
-  return this.getTypedRuleContext(ParameterContext, 0)
-}
-
-IdentifiedIndexLookupContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterIdentifiedIndexLookup(this)
-  }
-}
-
-IdentifiedIndexLookupContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitIdentifiedIndexLookup(this)
-  }
-}
-
-CypherParser.IdentifiedIndexLookupContext = IdentifiedIndexLookupContext
-
-CypherParser.prototype.identifiedIndexLookup = function() {
-  var localctx = new IdentifiedIndexLookupContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 206, CypherParser.RULE_identifiedIndexLookup)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1567
-    this.match(CypherParser.T__1)
-    this.state = 1568
-    this.symbolicName()
-    this.state = 1569
-    this.match(CypherParser.T__18)
-    this.state = 1570
-    this.symbolicName()
-    this.state = 1571
-    this.match(CypherParser.T__11)
-    this.state = 1574
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.StringLiteral:
-        this.state = 1572
-        this.match(CypherParser.StringLiteral)
-        break
-      case CypherParser.T__13:
-      case CypherParser.T__33:
-        this.state = 1573
-        this.parameter()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-    this.state = 1576
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function IndexQueryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_indexQuery
-  return this
-}
-
-IndexQueryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-IndexQueryContext.prototype.constructor = IndexQueryContext
-
-IndexQueryContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-IndexQueryContext.prototype.StringLiteral = function() {
-  return this.getToken(CypherParser.StringLiteral, 0)
-}
-
-IndexQueryContext.prototype.parameter = function() {
-  return this.getTypedRuleContext(ParameterContext, 0)
-}
-
-IndexQueryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterIndexQuery(this)
-  }
-}
-
-IndexQueryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitIndexQuery(this)
-  }
-}
-
-CypherParser.IndexQueryContext = IndexQueryContext
-
-CypherParser.prototype.indexQuery = function() {
-  var localctx = new IndexQueryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 208, CypherParser.RULE_indexQuery)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1578
-    this.match(CypherParser.T__1)
-    this.state = 1579
-    this.symbolicName()
-    this.state = 1580
-    this.match(CypherParser.T__18)
-    this.state = 1583
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.StringLiteral:
-        this.state = 1581
-        this.match(CypherParser.StringLiteral)
-        break
-      case CypherParser.T__13:
-      case CypherParser.T__33:
-        this.state = 1582
-        this.parameter()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-    this.state = 1585
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function IdLookupContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_idLookup
-  return this
-}
-
-IdLookupContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-IdLookupContext.prototype.constructor = IdLookupContext
-
-IdLookupContext.prototype.literalIds = function() {
-  return this.getTypedRuleContext(LiteralIdsContext, 0)
-}
-
-IdLookupContext.prototype.parameter = function() {
-  return this.getTypedRuleContext(ParameterContext, 0)
-}
-
-IdLookupContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterIdLookup(this)
-  }
-}
-
-IdLookupContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitIdLookup(this)
-  }
-}
-
-CypherParser.IdLookupContext = IdLookupContext
-
-CypherParser.prototype.idLookup = function() {
-  var localctx = new IdLookupContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 210, CypherParser.RULE_idLookup)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1587
-    this.match(CypherParser.T__18)
-    this.state = 1591
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.HexInteger:
-      case CypherParser.DecimalInteger:
-      case CypherParser.OctalInteger:
-        this.state = 1588
-        this.literalIds()
-        break
-      case CypherParser.T__13:
-      case CypherParser.T__33:
-        this.state = 1589
-        this.parameter()
-        break
-      case CypherParser.T__22:
-        this.state = 1590
-        this.match(CypherParser.T__22)
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-    this.state = 1593
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LiteralIdsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_literalIds
-  return this
-}
-
-LiteralIdsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-LiteralIdsContext.prototype.constructor = LiteralIdsContext
-
-LiteralIdsContext.prototype.integerLiteral = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(IntegerLiteralContext)
-  } else {
-    return this.getTypedRuleContext(IntegerLiteralContext, i)
-  }
-}
-
-LiteralIdsContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-LiteralIdsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLiteralIds(this)
-  }
-}
-
-LiteralIdsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLiteralIds(this)
-  }
-}
-
-CypherParser.LiteralIdsContext = LiteralIdsContext
-
-CypherParser.prototype.literalIds = function() {
-  var localctx = new LiteralIdsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 212, CypherParser.RULE_literalIds)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1595
-    this.integerLiteral()
-    this.state = 1606
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (_la === CypherParser.T__14 || _la === CypherParser.SP) {
-      this.state = 1597
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1596
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1599
-      this.match(CypherParser.T__14)
-      this.state = 1601
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1600
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1603
-      this.integerLiteral()
-      this.state = 1608
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function WhereContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_where
-  return this
-}
-
-WhereContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-WhereContext.prototype.constructor = WhereContext
-
-WhereContext.prototype.WHERE = function() {
-  return this.getToken(CypherParser.WHERE, 0)
-}
-
-WhereContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-WhereContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-WhereContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterWhere(this)
-  }
-}
-
-WhereContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitWhere(this)
-  }
-}
-
-CypherParser.WhereContext = WhereContext
-
-CypherParser.prototype.where = function() {
-  var localctx = new WhereContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 214, CypherParser.RULE_where)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1609
-    this.match(CypherParser.WHERE)
-    this.state = 1610
-    this.match(CypherParser.SP)
-    this.state = 1611
-    this.expression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PatternContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_pattern
-  return this
-}
-
-PatternContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-PatternContext.prototype.constructor = PatternContext
-
-PatternContext.prototype.patternPart = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PatternPartContext)
-  } else {
-    return this.getTypedRuleContext(PatternPartContext, i)
-  }
-}
-
-PatternContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PatternContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPattern(this)
-  }
-}
-
-PatternContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPattern(this)
-  }
-}
-
-CypherParser.PatternContext = PatternContext
-
-CypherParser.prototype.pattern = function() {
-  var localctx = new PatternContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 216, CypherParser.RULE_pattern)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1613
-    this.patternPart()
-    this.state = 1624
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 203, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1615
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1614
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1617
-        this.match(CypherParser.T__14)
-        this.state = 1619
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1618
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1621
-        this.patternPart()
-      }
-      this.state = 1626
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 203, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PatternPartContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_patternPart
-  return this
-}
-
-PatternPartContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-PatternPartContext.prototype.constructor = PatternPartContext
-
-PatternPartContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-PatternPartContext.prototype.anonymousPatternPart = function() {
-  return this.getTypedRuleContext(AnonymousPatternPartContext, 0)
-}
-
-PatternPartContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PatternPartContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPatternPart(this)
-  }
-}
-
-PatternPartContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPatternPart(this)
-  }
-}
-
-CypherParser.PatternPartContext = PatternPartContext
-
-CypherParser.prototype.patternPart = function() {
-  var localctx = new PatternPartContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 218, CypherParser.RULE_patternPart)
-  var _la = 0 // Token type
-  try {
-    this.state = 1638
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 206, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1627
-        this.variable()
-        this.state = 1629
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1628
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1631
-        this.match(CypherParser.T__11)
-        this.state = 1633
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1632
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1635
-        this.anonymousPatternPart()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1637
-        this.anonymousPatternPart()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AnonymousPatternPartContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_anonymousPatternPart
-  return this
-}
-
-AnonymousPatternPartContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AnonymousPatternPartContext.prototype.constructor = AnonymousPatternPartContext
-
-AnonymousPatternPartContext.prototype.shortestPathPatternFunction = function() {
-  return this.getTypedRuleContext(ShortestPathPatternFunctionContext, 0)
-}
-
-AnonymousPatternPartContext.prototype.patternElement = function() {
-  return this.getTypedRuleContext(PatternElementContext, 0)
-}
-
-AnonymousPatternPartContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAnonymousPatternPart(this)
-  }
-}
-
-AnonymousPatternPartContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAnonymousPatternPart(this)
-  }
-}
-
-CypherParser.AnonymousPatternPartContext = AnonymousPatternPartContext
-
-CypherParser.prototype.anonymousPatternPart = function() {
-  var localctx = new AnonymousPatternPartContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 220, CypherParser.RULE_anonymousPatternPart)
-  try {
-    this.state = 1642
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.SHORTESTPATH:
-      case CypherParser.ALLSHORTESTPATHS:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1640
-        this.shortestPathPatternFunction()
-        break
-      case CypherParser.T__18:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1641
-        this.patternElement()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PatternElementContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_patternElement
-  return this
-}
-
-PatternElementContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PatternElementContext.prototype.constructor = PatternElementContext
-
-PatternElementContext.prototype.nodePattern = function() {
-  return this.getTypedRuleContext(NodePatternContext, 0)
-}
-
-PatternElementContext.prototype.patternElementChain = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PatternElementChainContext)
-  } else {
-    return this.getTypedRuleContext(PatternElementChainContext, i)
-  }
-}
-
-PatternElementContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PatternElementContext.prototype.patternElement = function() {
-  return this.getTypedRuleContext(PatternElementContext, 0)
-}
-
-PatternElementContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPatternElement(this)
-  }
-}
-
-PatternElementContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPatternElement(this)
-  }
-}
-
-CypherParser.PatternElementContext = PatternElementContext
-
-CypherParser.prototype.patternElement = function() {
-  var localctx = new PatternElementContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 222, CypherParser.RULE_patternElement)
-  var _la = 0 // Token type
-  try {
-    this.state = 1658
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 210, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1644
-        this.nodePattern()
-        this.state = 1651
-        this._errHandler.sync(this)
-        var _alt = this._interp.adaptivePredict(this._input, 209, this._ctx)
-        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-          if (_alt === 1) {
-            this.state = 1646
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1645
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1648
-            this.patternElementChain()
-          }
-          this.state = 1653
-          this._errHandler.sync(this)
-          _alt = this._interp.adaptivePredict(this._input, 209, this._ctx)
-        }
-
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1654
-        this.match(CypherParser.T__18)
-        this.state = 1655
-        this.patternElement()
-        this.state = 1656
-        this.match(CypherParser.T__19)
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NodePatternContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_nodePattern
-  return this
-}
-
-NodePatternContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-NodePatternContext.prototype.constructor = NodePatternContext
-
-NodePatternContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-NodePatternContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-NodePatternContext.prototype.nodeLabels = function() {
-  return this.getTypedRuleContext(NodeLabelsContext, 0)
-}
-
-NodePatternContext.prototype.properties = function() {
-  return this.getTypedRuleContext(PropertiesContext, 0)
-}
-
-NodePatternContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNodePattern(this)
-  }
-}
-
-NodePatternContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNodePattern(this)
-  }
-}
-
-CypherParser.NodePatternContext = NodePatternContext
-
-CypherParser.prototype.nodePattern = function() {
-  var localctx = new NodePatternContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 224, CypherParser.RULE_nodePattern)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1660
-    this.match(CypherParser.T__18)
-    this.state = 1662
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1661
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1668
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      (((_la - 54) & ~0x1f) == 0 &&
-        ((1 << (_la - 54)) &
-          ((1 << (CypherParser.CYPHER - 54)) |
-            (1 << (CypherParser.EXPLAIN - 54)) |
-            (1 << (CypherParser.PROFILE - 54)) |
-            (1 << (CypherParser.USING - 54)) |
-            (1 << (CypherParser.PERIODIC - 54)) |
-            (1 << (CypherParser.COMMIT - 54)) |
-            (1 << (CypherParser.UNION - 54)) |
-            (1 << (CypherParser.ALL - 54)) |
-            (1 << (CypherParser.CREATE - 54)) |
-            (1 << (CypherParser.DROP - 54)) |
-            (1 << (CypherParser.INDEX - 54)) |
-            (1 << (CypherParser.ON - 54)) |
-            (1 << (CypherParser.CONSTRAINT - 54)) |
-            (1 << (CypherParser.ASSERT - 54)) |
-            (1 << (CypherParser.IS - 54)) |
-            (1 << (CypherParser.UNIQUE - 54)) |
-            (1 << (CypherParser.EXISTS - 54)) |
-            (1 << (CypherParser.LOAD - 54)) |
-            (1 << (CypherParser.CSV - 54)) |
-            (1 << (CypherParser.WITH - 54)) |
-            (1 << (CypherParser.HEADERS - 54)) |
-            (1 << (CypherParser.FROM - 54)) |
-            (1 << (CypherParser.AS - 54)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
-            (1 << (CypherParser.OPTIONAL - 54)) |
-            (1 << (CypherParser.MATCH - 54)) |
-            (1 << (CypherParser.UNWIND - 54)) |
-            (1 << (CypherParser.MERGE - 54)) |
-            (1 << (CypherParser.SET - 54)) |
-            (1 << (CypherParser.DETACH - 54)) |
-            (1 << (CypherParser.DELETE - 54)) |
-            (1 << (CypherParser.REMOVE - 54)))) !==
-          0) ||
-      (((_la - 86) & ~0x1f) == 0 &&
-        ((1 << (_la - 86)) &
-          ((1 << (CypherParser.FOREACH - 86)) |
-            (1 << (CypherParser.IN - 86)) |
-            (1 << (CypherParser.DISTINCT - 86)) |
-            (1 << (CypherParser.RETURN - 86)) |
-            (1 << (CypherParser.ORDER - 86)) |
-            (1 << (CypherParser.BY - 86)) |
-            (1 << (CypherParser.L_SKIP - 86)) |
-            (1 << (CypherParser.LIMIT - 86)) |
-            (1 << (CypherParser.ASCENDING - 86)) |
-            (1 << (CypherParser.ASC - 86)) |
-            (1 << (CypherParser.DESCENDING - 86)) |
-            (1 << (CypherParser.DESC - 86)) |
-            (1 << (CypherParser.JOIN - 86)) |
-            (1 << (CypherParser.SCAN - 86)) |
-            (1 << (CypherParser.START - 86)) |
-            (1 << (CypherParser.NODE - 86)) |
-            (1 << (CypherParser.RELATIONSHIP - 86)) |
-            (1 << (CypherParser.REL - 86)) |
-            (1 << (CypherParser.WHERE - 86)) |
-            (1 << (CypherParser.SHORTESTPATH - 86)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
-            (1 << (CypherParser.OR - 86)) |
-            (1 << (CypherParser.XOR - 86)) |
-            (1 << (CypherParser.AND - 86)) |
-            (1 << (CypherParser.NOT - 86)) |
-            (1 << (CypherParser.STARTS - 86)) |
-            (1 << (CypherParser.ENDS - 86)) |
-            (1 << (CypherParser.CONTAINS - 86)) |
-            (1 << (CypherParser.NULL - 86)) |
-            (1 << (CypherParser.COUNT - 86)) |
-            (1 << (CypherParser.FILTER - 86)) |
-            (1 << (CypherParser.EXTRACT - 86)))) !==
-          0) ||
-      (((_la - 118) & ~0x1f) == 0 &&
-        ((1 << (_la - 118)) &
-          ((1 << (CypherParser.ANY - 118)) |
-            (1 << (CypherParser.NONE - 118)) |
-            (1 << (CypherParser.SINGLE - 118)) |
-            (1 << (CypherParser.TRUE - 118)) |
-            (1 << (CypherParser.FALSE - 118)) |
-            (1 << (CypherParser.REDUCE - 118)) |
-            (1 << (CypherParser.CASE - 118)) |
-            (1 << (CypherParser.ELSE - 118)) |
-            (1 << (CypherParser.END - 118)) |
-            (1 << (CypherParser.WHEN - 118)) |
-            (1 << (CypherParser.THEN - 118)) |
-            (1 << (CypherParser.CALL - 118)) |
-            (1 << (CypherParser.YIELD - 118)) |
-            (1 << (CypherParser.KEY - 118)) |
-            (1 << (CypherParser.HexLetter - 118)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
-          0) ||
-      _la === CypherParser.EscapedSymbolicName
-    ) {
-      this.state = 1664
-      this.variable()
-      this.state = 1666
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1665
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 1674
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__1) {
-      this.state = 1670
-      this.nodeLabels()
-      this.state = 1672
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1671
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 1680
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__13 || _la === CypherParser.T__33) {
-      this.state = 1676
-      this.properties()
-      this.state = 1678
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1677
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 1682
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PatternElementChainContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_patternElementChain
-  return this
-}
-
-PatternElementChainContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PatternElementChainContext.prototype.constructor = PatternElementChainContext
-
-PatternElementChainContext.prototype.relationshipPattern = function() {
-  return this.getTypedRuleContext(RelationshipPatternContext, 0)
-}
-
-PatternElementChainContext.prototype.nodePattern = function() {
-  return this.getTypedRuleContext(NodePatternContext, 0)
-}
-
-PatternElementChainContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-PatternElementChainContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPatternElementChain(this)
-  }
-}
-
-PatternElementChainContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPatternElementChain(this)
-  }
-}
-
-CypherParser.PatternElementChainContext = PatternElementChainContext
-
-CypherParser.prototype.patternElementChain = function() {
-  var localctx = new PatternElementChainContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 226, CypherParser.RULE_patternElementChain)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1684
-    this.relationshipPattern()
-    this.state = 1686
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1685
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1688
-    this.nodePattern()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipPatternContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipPattern
-  return this
-}
-
-RelationshipPatternContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipPatternContext.prototype.constructor = RelationshipPatternContext
-
-RelationshipPatternContext.prototype.relationshipPatternStart = function() {
-  return this.getTypedRuleContext(RelationshipPatternStartContext, 0)
-}
-
-RelationshipPatternContext.prototype.relationshipPatternEnd = function() {
-  return this.getTypedRuleContext(RelationshipPatternEndContext, 0)
-}
-
-RelationshipPatternContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RelationshipPatternContext.prototype.relationshipDetail = function() {
-  return this.getTypedRuleContext(RelationshipDetailContext, 0)
-}
-
-RelationshipPatternContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipPattern(this)
-  }
-}
-
-RelationshipPatternContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipPattern(this)
-  }
-}
-
-CypherParser.RelationshipPatternContext = RelationshipPatternContext
-
-CypherParser.prototype.relationshipPattern = function() {
-  var localctx = new RelationshipPatternContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 228, CypherParser.RULE_relationshipPattern)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1690
-    this.relationshipPatternStart()
-    this.state = 1692
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 219, this._ctx)
-    if (la_ === 1) {
-      this.state = 1691
-      this.match(CypherParser.SP)
-    }
-    this.state = 1695
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__16) {
-      this.state = 1694
-      this.relationshipDetail()
-    }
-
-    this.state = 1698
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1697
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1700
-    this.relationshipPatternEnd()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipPatternStartContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipPatternStart
-  return this
-}
-
-RelationshipPatternStartContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipPatternStartContext.prototype.constructor = RelationshipPatternStartContext
-
-RelationshipPatternStartContext.prototype.leftArrowHead = function() {
-  return this.getTypedRuleContext(LeftArrowHeadContext, 0)
-}
-
-RelationshipPatternStartContext.prototype.dash = function() {
-  return this.getTypedRuleContext(DashContext, 0)
-}
-
-RelationshipPatternStartContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-RelationshipPatternStartContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipPatternStart(this)
-  }
-}
-
-RelationshipPatternStartContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipPatternStart(this)
-  }
-}
-
-CypherParser.RelationshipPatternStartContext = RelationshipPatternStartContext
-
-CypherParser.prototype.relationshipPatternStart = function() {
-  var localctx = new RelationshipPatternStartContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 230, CypherParser.RULE_relationshipPatternStart)
-  var _la = 0 // Token type
-  try {
-    this.state = 1709
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.T__29:
-      case CypherParser.T__34:
-      case CypherParser.T__35:
-      case CypherParser.T__36:
-      case CypherParser.T__37:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1702
-        this.leftArrowHead()
-        this.state = 1704
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1703
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1706
-        this.dash()
-        break
-      case CypherParser.T__2:
-      case CypherParser.T__42:
-      case CypherParser.T__43:
-      case CypherParser.T__44:
-      case CypherParser.T__45:
-      case CypherParser.T__46:
-      case CypherParser.T__47:
-      case CypherParser.T__48:
-      case CypherParser.T__49:
-      case CypherParser.T__50:
-      case CypherParser.T__51:
-      case CypherParser.T__52:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1708
-        this.dash()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipPatternEndContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipPatternEnd
-  return this
-}
-
-RelationshipPatternEndContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipPatternEndContext.prototype.constructor = RelationshipPatternEndContext
-
-RelationshipPatternEndContext.prototype.dash = function() {
-  return this.getTypedRuleContext(DashContext, 0)
-}
-
-RelationshipPatternEndContext.prototype.rightArrowHead = function() {
-  return this.getTypedRuleContext(RightArrowHeadContext, 0)
-}
-
-RelationshipPatternEndContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-RelationshipPatternEndContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipPatternEnd(this)
-  }
-}
-
-RelationshipPatternEndContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipPatternEnd(this)
-  }
-}
-
-CypherParser.RelationshipPatternEndContext = RelationshipPatternEndContext
-
-CypherParser.prototype.relationshipPatternEnd = function() {
-  var localctx = new RelationshipPatternEndContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 232, CypherParser.RULE_relationshipPatternEnd)
-  var _la = 0 // Token type
-  try {
-    this.state = 1718
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 225, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1711
-        this.dash()
-        this.state = 1713
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1712
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1715
-        this.rightArrowHead()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1717
-        this.dash()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipDetailContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipDetail
-  return this
-}
-
-RelationshipDetailContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipDetailContext.prototype.constructor = RelationshipDetailContext
-
-RelationshipDetailContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RelationshipDetailContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-RelationshipDetailContext.prototype.relationshipTypes = function() {
-  return this.getTypedRuleContext(RelationshipTypesContext, 0)
-}
-
-RelationshipDetailContext.prototype.rangeLiteral = function() {
-  return this.getTypedRuleContext(RangeLiteralContext, 0)
-}
-
-RelationshipDetailContext.prototype.properties = function() {
-  return this.getTypedRuleContext(PropertiesContext, 0)
-}
-
-RelationshipDetailContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipDetail(this)
-  }
-}
-
-RelationshipDetailContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipDetail(this)
-  }
-}
-
-CypherParser.RelationshipDetailContext = RelationshipDetailContext
-
-CypherParser.prototype.relationshipDetail = function() {
-  var localctx = new RelationshipDetailContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 234, CypherParser.RULE_relationshipDetail)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1720
-    this.match(CypherParser.T__16)
-    this.state = 1722
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1721
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1728
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      (((_la - 54) & ~0x1f) == 0 &&
-        ((1 << (_la - 54)) &
-          ((1 << (CypherParser.CYPHER - 54)) |
-            (1 << (CypherParser.EXPLAIN - 54)) |
-            (1 << (CypherParser.PROFILE - 54)) |
-            (1 << (CypherParser.USING - 54)) |
-            (1 << (CypherParser.PERIODIC - 54)) |
-            (1 << (CypherParser.COMMIT - 54)) |
-            (1 << (CypherParser.UNION - 54)) |
-            (1 << (CypherParser.ALL - 54)) |
-            (1 << (CypherParser.CREATE - 54)) |
-            (1 << (CypherParser.DROP - 54)) |
-            (1 << (CypherParser.INDEX - 54)) |
-            (1 << (CypherParser.ON - 54)) |
-            (1 << (CypherParser.CONSTRAINT - 54)) |
-            (1 << (CypherParser.ASSERT - 54)) |
-            (1 << (CypherParser.IS - 54)) |
-            (1 << (CypherParser.UNIQUE - 54)) |
-            (1 << (CypherParser.EXISTS - 54)) |
-            (1 << (CypherParser.LOAD - 54)) |
-            (1 << (CypherParser.CSV - 54)) |
-            (1 << (CypherParser.WITH - 54)) |
-            (1 << (CypherParser.HEADERS - 54)) |
-            (1 << (CypherParser.FROM - 54)) |
-            (1 << (CypherParser.AS - 54)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
-            (1 << (CypherParser.OPTIONAL - 54)) |
-            (1 << (CypherParser.MATCH - 54)) |
-            (1 << (CypherParser.UNWIND - 54)) |
-            (1 << (CypherParser.MERGE - 54)) |
-            (1 << (CypherParser.SET - 54)) |
-            (1 << (CypherParser.DETACH - 54)) |
-            (1 << (CypherParser.DELETE - 54)) |
-            (1 << (CypherParser.REMOVE - 54)))) !==
-          0) ||
-      (((_la - 86) & ~0x1f) == 0 &&
-        ((1 << (_la - 86)) &
-          ((1 << (CypherParser.FOREACH - 86)) |
-            (1 << (CypherParser.IN - 86)) |
-            (1 << (CypherParser.DISTINCT - 86)) |
-            (1 << (CypherParser.RETURN - 86)) |
-            (1 << (CypherParser.ORDER - 86)) |
-            (1 << (CypherParser.BY - 86)) |
-            (1 << (CypherParser.L_SKIP - 86)) |
-            (1 << (CypherParser.LIMIT - 86)) |
-            (1 << (CypherParser.ASCENDING - 86)) |
-            (1 << (CypherParser.ASC - 86)) |
-            (1 << (CypherParser.DESCENDING - 86)) |
-            (1 << (CypherParser.DESC - 86)) |
-            (1 << (CypherParser.JOIN - 86)) |
-            (1 << (CypherParser.SCAN - 86)) |
-            (1 << (CypherParser.START - 86)) |
-            (1 << (CypherParser.NODE - 86)) |
-            (1 << (CypherParser.RELATIONSHIP - 86)) |
-            (1 << (CypherParser.REL - 86)) |
-            (1 << (CypherParser.WHERE - 86)) |
-            (1 << (CypherParser.SHORTESTPATH - 86)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
-            (1 << (CypherParser.OR - 86)) |
-            (1 << (CypherParser.XOR - 86)) |
-            (1 << (CypherParser.AND - 86)) |
-            (1 << (CypherParser.NOT - 86)) |
-            (1 << (CypherParser.STARTS - 86)) |
-            (1 << (CypherParser.ENDS - 86)) |
-            (1 << (CypherParser.CONTAINS - 86)) |
-            (1 << (CypherParser.NULL - 86)) |
-            (1 << (CypherParser.COUNT - 86)) |
-            (1 << (CypherParser.FILTER - 86)) |
-            (1 << (CypherParser.EXTRACT - 86)))) !==
-          0) ||
-      (((_la - 118) & ~0x1f) == 0 &&
-        ((1 << (_la - 118)) &
-          ((1 << (CypherParser.ANY - 118)) |
-            (1 << (CypherParser.NONE - 118)) |
-            (1 << (CypherParser.SINGLE - 118)) |
-            (1 << (CypherParser.TRUE - 118)) |
-            (1 << (CypherParser.FALSE - 118)) |
-            (1 << (CypherParser.REDUCE - 118)) |
-            (1 << (CypherParser.CASE - 118)) |
-            (1 << (CypherParser.ELSE - 118)) |
-            (1 << (CypherParser.END - 118)) |
-            (1 << (CypherParser.WHEN - 118)) |
-            (1 << (CypherParser.THEN - 118)) |
-            (1 << (CypherParser.CALL - 118)) |
-            (1 << (CypherParser.YIELD - 118)) |
-            (1 << (CypherParser.KEY - 118)) |
-            (1 << (CypherParser.HexLetter - 118)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
-          0) ||
-      _la === CypherParser.EscapedSymbolicName
-    ) {
-      this.state = 1724
-      this.variable()
-      this.state = 1726
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1725
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 1734
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__1) {
-      this.state = 1730
-      this.relationshipTypes()
-      this.state = 1732
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1731
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 1737
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__22) {
-      this.state = 1736
-      this.rangeLiteral()
-    }
-
-    this.state = 1743
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__13 || _la === CypherParser.T__33) {
-      this.state = 1739
-      this.properties()
-      this.state = 1741
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1740
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 1745
-    this.match(CypherParser.T__17)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertiesContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_properties
-  return this
-}
-
-PropertiesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-PropertiesContext.prototype.constructor = PropertiesContext
-
-PropertiesContext.prototype.mapLiteral = function() {
-  return this.getTypedRuleContext(MapLiteralContext, 0)
-}
-
-PropertiesContext.prototype.parameter = function() {
-  return this.getTypedRuleContext(ParameterContext, 0)
-}
-
-PropertiesContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProperties(this)
-  }
-}
-
-PropertiesContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProperties(this)
-  }
-}
-
-CypherParser.PropertiesContext = PropertiesContext
-
-CypherParser.prototype.properties = function() {
-  var localctx = new PropertiesContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 236, CypherParser.RULE_properties)
-  try {
-    this.state = 1749
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 234, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 1747
-        this.mapLiteral()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 1748
-        this.parameter()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelTypeContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relType
-  return this
-}
-
-RelTypeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-RelTypeContext.prototype.constructor = RelTypeContext
-
-RelTypeContext.prototype.relTypeName = function() {
-  return this.getTypedRuleContext(RelTypeNameContext, 0)
-}
-
-RelTypeContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-RelTypeContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelType(this)
-  }
-}
-
-RelTypeContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelType(this)
-  }
-}
-
-CypherParser.RelTypeContext = RelTypeContext
-
-CypherParser.prototype.relType = function() {
-  var localctx = new RelTypeContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 238, CypherParser.RULE_relType)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1751
-    this.match(CypherParser.T__1)
-    this.state = 1753
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1752
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1755
-    this.relTypeName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipTypesContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipTypes
-  return this
-}
-
-RelationshipTypesContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipTypesContext.prototype.constructor = RelationshipTypesContext
-
-RelationshipTypesContext.prototype.relationshipType = function() {
-  return this.getTypedRuleContext(RelationshipTypeContext, 0)
-}
-
-RelationshipTypesContext.prototype.relationshipTypeOptionalColon = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(RelationshipTypeOptionalColonContext)
-  } else {
-    return this.getTypedRuleContext(RelationshipTypeOptionalColonContext, i)
-  }
-}
-
-RelationshipTypesContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RelationshipTypesContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipTypes(this)
-  }
-}
-
-RelationshipTypesContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipTypes(this)
-  }
-}
-
-CypherParser.RelationshipTypesContext = RelationshipTypesContext
-
-CypherParser.prototype.relationshipTypes = function() {
-  var localctx = new RelationshipTypesContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 240, CypherParser.RULE_relationshipTypes)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1757
-    this.relationshipType()
-    this.state = 1765
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 237, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1759
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1758
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1761
-        this.match(CypherParser.T__21)
-        this.state = 1762
-        this.relationshipTypeOptionalColon()
-      }
-      this.state = 1767
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 237, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipTypeContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipType
-  return this
-}
-
-RelationshipTypeContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipTypeContext.prototype.constructor = RelationshipTypeContext
-
-RelationshipTypeContext.prototype.relTypeName = function() {
-  return this.getTypedRuleContext(RelTypeNameContext, 0)
-}
-
-RelationshipTypeContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipType(this)
-  }
-}
-
-RelationshipTypeContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipType(this)
-  }
-}
-
-CypherParser.RelationshipTypeContext = RelationshipTypeContext
-
-CypherParser.prototype.relationshipType = function() {
-  var localctx = new RelationshipTypeContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 242, CypherParser.RULE_relationshipType)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1768
-    this.match(CypherParser.T__1)
-    this.state = 1769
-    this.relTypeName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipTypeOptionalColonContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipTypeOptionalColon
-  return this
-}
-
-RelationshipTypeOptionalColonContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipTypeOptionalColonContext.prototype.constructor = RelationshipTypeOptionalColonContext
-
-RelationshipTypeOptionalColonContext.prototype.relTypeName = function() {
-  return this.getTypedRuleContext(RelTypeNameContext, 0)
-}
-
-RelationshipTypeOptionalColonContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipTypeOptionalColon(this)
-  }
-}
-
-RelationshipTypeOptionalColonContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipTypeOptionalColon(this)
-  }
-}
-
-CypherParser.RelationshipTypeOptionalColonContext = RelationshipTypeOptionalColonContext
-
-CypherParser.prototype.relationshipTypeOptionalColon = function() {
-  var localctx = new RelationshipTypeOptionalColonContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 244, CypherParser.RULE_relationshipTypeOptionalColon)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1772
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__1) {
-      this.state = 1771
-      this.match(CypherParser.T__1)
-    }
-
-    this.state = 1774
-    this.relTypeName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NodeLabelsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_nodeLabels
-  return this
-}
-
-NodeLabelsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-NodeLabelsContext.prototype.constructor = NodeLabelsContext
-
-NodeLabelsContext.prototype.nodeLabel = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(NodeLabelContext)
-  } else {
-    return this.getTypedRuleContext(NodeLabelContext, i)
-  }
-}
-
-NodeLabelsContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-NodeLabelsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNodeLabels(this)
-  }
-}
-
-NodeLabelsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNodeLabels(this)
-  }
-}
-
-CypherParser.NodeLabelsContext = NodeLabelsContext
-
-CypherParser.prototype.nodeLabels = function() {
-  var localctx = new NodeLabelsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 246, CypherParser.RULE_nodeLabels)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1776
-    this.nodeLabel()
-    this.state = 1783
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 240, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1778
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1777
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1780
-        this.nodeLabel()
-      }
-      this.state = 1785
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 240, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NodeLabelContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_nodeLabel
-  return this
-}
-
-NodeLabelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-NodeLabelContext.prototype.constructor = NodeLabelContext
-
-NodeLabelContext.prototype.labelName = function() {
-  return this.getTypedRuleContext(LabelNameContext, 0)
-}
-
-NodeLabelContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNodeLabel(this)
-  }
-}
-
-NodeLabelContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNodeLabel(this)
-  }
-}
-
-CypherParser.NodeLabelContext = NodeLabelContext
-
-CypherParser.prototype.nodeLabel = function() {
-  var localctx = new NodeLabelContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 248, CypherParser.RULE_nodeLabel)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1786
-    this.match(CypherParser.T__1)
-    this.state = 1787
-    this.labelName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RangeLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_rangeLiteral
-  return this
-}
-
-RangeLiteralContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RangeLiteralContext.prototype.constructor = RangeLiteralContext
-
-RangeLiteralContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RangeLiteralContext.prototype.integerLiteral = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(IntegerLiteralContext)
-  } else {
-    return this.getTypedRuleContext(IntegerLiteralContext, i)
-  }
-}
-
-RangeLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRangeLiteral(this)
-  }
-}
-
-RangeLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRangeLiteral(this)
-  }
-}
-
-CypherParser.RangeLiteralContext = RangeLiteralContext
-
-CypherParser.prototype.rangeLiteral = function() {
-  var localctx = new RangeLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 250, CypherParser.RULE_rangeLiteral)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1789
-    this.match(CypherParser.T__22)
-    this.state = 1791
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 1790
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 1797
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      ((_la - 135) & ~0x1f) == 0 &&
-      ((1 << (_la - 135)) &
-        ((1 << (CypherParser.HexInteger - 135)) |
-          (1 << (CypherParser.DecimalInteger - 135)) |
-          (1 << (CypherParser.OctalInteger - 135)))) !==
-        0
-    ) {
-      this.state = 1793
-      this.integerLiteral()
-      this.state = 1795
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1794
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 1809
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.T__23) {
-      this.state = 1799
-      this.match(CypherParser.T__23)
-      this.state = 1801
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1800
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1807
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (
-        ((_la - 135) & ~0x1f) == 0 &&
-        ((1 << (_la - 135)) &
-          ((1 << (CypherParser.HexInteger - 135)) |
-            (1 << (CypherParser.DecimalInteger - 135)) |
-            (1 << (CypherParser.OctalInteger - 135)))) !==
-          0
-      ) {
-        this.state = 1803
-        this.integerLiteral()
-        this.state = 1805
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1804
-          this.match(CypherParser.SP)
-        }
-      }
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LabelNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_labelName
-  return this
-}
-
-LabelNameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-LabelNameContext.prototype.constructor = LabelNameContext
-
-LabelNameContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-LabelNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLabelName(this)
-  }
-}
-
-LabelNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLabelName(this)
-  }
-}
-
-CypherParser.LabelNameContext = LabelNameContext
-
-CypherParser.prototype.labelName = function() {
-  var localctx = new LabelNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 252, CypherParser.RULE_labelName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1811
-    this.symbolicName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelTypeNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relTypeName
-  return this
-}
-
-RelTypeNameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-RelTypeNameContext.prototype.constructor = RelTypeNameContext
-
-RelTypeNameContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-RelTypeNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelTypeName(this)
-  }
-}
-
-RelTypeNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelTypeName(this)
-  }
-}
-
-CypherParser.RelTypeNameContext = RelTypeNameContext
-
-CypherParser.prototype.relTypeName = function() {
-  var localctx = new RelTypeNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 254, CypherParser.RULE_relTypeName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1813
-    this.symbolicName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_expression
-  return this
-}
-
-ExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ExpressionContext.prototype.constructor = ExpressionContext
-
-ExpressionContext.prototype.orExpression = function() {
-  return this.getTypedRuleContext(OrExpressionContext, 0)
-}
-
-ExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterExpression(this)
-  }
-}
-
-ExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitExpression(this)
-  }
-}
-
-CypherParser.ExpressionContext = ExpressionContext
-
-CypherParser.prototype.expression = function() {
-  var localctx = new ExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 256, CypherParser.RULE_expression)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1815
-    this.orExpression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function OrExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_orExpression
-  return this
-}
-
-OrExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-OrExpressionContext.prototype.constructor = OrExpressionContext
-
-OrExpressionContext.prototype.xorExpression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(XorExpressionContext)
-  } else {
-    return this.getTypedRuleContext(XorExpressionContext, i)
-  }
-}
-
-OrExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-OrExpressionContext.prototype.OR = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.OR)
-  } else {
-    return this.getToken(CypherParser.OR, i)
-  }
-}
-
-OrExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterOrExpression(this)
-  }
-}
-
-OrExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitOrExpression(this)
-  }
-}
-
-CypherParser.OrExpressionContext = OrExpressionContext
-
-CypherParser.prototype.orExpression = function() {
-  var localctx = new OrExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 258, CypherParser.RULE_orExpression)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1817
-    this.xorExpression()
-    this.state = 1824
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 248, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1818
-        this.match(CypherParser.SP)
-        this.state = 1819
-        this.match(CypherParser.OR)
-        this.state = 1820
-        this.match(CypherParser.SP)
-        this.state = 1821
-        this.xorExpression()
-      }
-      this.state = 1826
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 248, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function XorExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_xorExpression
-  return this
-}
-
-XorExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-XorExpressionContext.prototype.constructor = XorExpressionContext
-
-XorExpressionContext.prototype.andExpression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(AndExpressionContext)
-  } else {
-    return this.getTypedRuleContext(AndExpressionContext, i)
-  }
-}
-
-XorExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-XorExpressionContext.prototype.XOR = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.XOR)
-  } else {
-    return this.getToken(CypherParser.XOR, i)
-  }
-}
-
-XorExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterXorExpression(this)
-  }
-}
-
-XorExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitXorExpression(this)
-  }
-}
-
-CypherParser.XorExpressionContext = XorExpressionContext
-
-CypherParser.prototype.xorExpression = function() {
-  var localctx = new XorExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 260, CypherParser.RULE_xorExpression)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1827
-    this.andExpression()
-    this.state = 1834
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 249, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1828
-        this.match(CypherParser.SP)
-        this.state = 1829
-        this.match(CypherParser.XOR)
-        this.state = 1830
-        this.match(CypherParser.SP)
-        this.state = 1831
-        this.andExpression()
-      }
-      this.state = 1836
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 249, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AndExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_andExpression
-  return this
-}
-
-AndExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AndExpressionContext.prototype.constructor = AndExpressionContext
-
-AndExpressionContext.prototype.notExpression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(NotExpressionContext)
-  } else {
-    return this.getTypedRuleContext(NotExpressionContext, i)
-  }
-}
-
-AndExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-AndExpressionContext.prototype.AND = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.AND)
-  } else {
-    return this.getToken(CypherParser.AND, i)
-  }
-}
-
-AndExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAndExpression(this)
-  }
-}
-
-AndExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAndExpression(this)
-  }
-}
-
-CypherParser.AndExpressionContext = AndExpressionContext
-
-CypherParser.prototype.andExpression = function() {
-  var localctx = new AndExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 262, CypherParser.RULE_andExpression)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1837
-    this.notExpression()
-    this.state = 1844
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 250, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1838
-        this.match(CypherParser.SP)
-        this.state = 1839
-        this.match(CypherParser.AND)
-        this.state = 1840
-        this.match(CypherParser.SP)
-        this.state = 1841
-        this.notExpression()
-      }
-      this.state = 1846
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 250, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NotExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_notExpression
-  return this
-}
-
-NotExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-NotExpressionContext.prototype.constructor = NotExpressionContext
-
-NotExpressionContext.prototype.comparisonExpression = function() {
-  return this.getTypedRuleContext(ComparisonExpressionContext, 0)
-}
-
-NotExpressionContext.prototype.NOT = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.NOT)
-  } else {
-    return this.getToken(CypherParser.NOT, i)
-  }
-}
-
-NotExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-NotExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNotExpression(this)
-  }
-}
-
-NotExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNotExpression(this)
-  }
-}
-
-CypherParser.NotExpressionContext = NotExpressionContext
-
-CypherParser.prototype.notExpression = function() {
-  var localctx = new NotExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 264, CypherParser.RULE_notExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1853
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 252, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1847
-        this.match(CypherParser.NOT)
-        this.state = 1849
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1848
-          this.match(CypherParser.SP)
-        }
-      }
-      this.state = 1855
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 252, this._ctx)
-    }
-
-    this.state = 1856
-    this.comparisonExpression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ComparisonExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_comparisonExpression
-  return this
-}
-
-ComparisonExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ComparisonExpressionContext.prototype.constructor = ComparisonExpressionContext
-
-ComparisonExpressionContext.prototype.addOrSubtractExpression = function() {
-  return this.getTypedRuleContext(AddOrSubtractExpressionContext, 0)
-}
-
-ComparisonExpressionContext.prototype.partialComparisonExpression = function(
-  i
-) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PartialComparisonExpressionContext)
-  } else {
-    return this.getTypedRuleContext(PartialComparisonExpressionContext, i)
-  }
-}
-
-ComparisonExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ComparisonExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterComparisonExpression(this)
-  }
-}
-
-ComparisonExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitComparisonExpression(this)
-  }
-}
-
-CypherParser.ComparisonExpressionContext = ComparisonExpressionContext
-
-CypherParser.prototype.comparisonExpression = function() {
-  var localctx = new ComparisonExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 266, CypherParser.RULE_comparisonExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1858
-    this.addOrSubtractExpression()
-    this.state = 1865
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 254, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1860
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1859
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1862
-        this.partialComparisonExpression()
-      }
-      this.state = 1867
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 254, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AddOrSubtractExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_addOrSubtractExpression
-  return this
-}
-
-AddOrSubtractExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AddOrSubtractExpressionContext.prototype.constructor = AddOrSubtractExpressionContext
-
-AddOrSubtractExpressionContext.prototype.multiplyDivideModuloExpression = function(
-  i
-) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(MultiplyDivideModuloExpressionContext)
-  } else {
-    return this.getTypedRuleContext(MultiplyDivideModuloExpressionContext, i)
-  }
-}
-
-AddOrSubtractExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-AddOrSubtractExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAddOrSubtractExpression(this)
-  }
-}
-
-AddOrSubtractExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAddOrSubtractExpression(this)
-  }
-}
-
-CypherParser.AddOrSubtractExpressionContext = AddOrSubtractExpressionContext
-
-CypherParser.prototype.addOrSubtractExpression = function() {
-  var localctx = new AddOrSubtractExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 268, CypherParser.RULE_addOrSubtractExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1868
-    this.multiplyDivideModuloExpression()
-    this.state = 1887
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 260, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1885
-        this._errHandler.sync(this)
-        var la_ = this._interp.adaptivePredict(this._input, 259, this._ctx)
-        switch (la_) {
-          case 1:
-            this.state = 1870
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1869
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1872
-            this.match(CypherParser.T__12)
-            this.state = 1874
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1873
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1876
-            this.multiplyDivideModuloExpression()
-            break
-
-          case 2:
-            this.state = 1878
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1877
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1880
-            this.match(CypherParser.T__2)
-            this.state = 1882
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1881
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1884
-            this.multiplyDivideModuloExpression()
-            break
-        }
-      }
-      this.state = 1889
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 260, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function MultiplyDivideModuloExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_multiplyDivideModuloExpression
-  return this
-}
-
-MultiplyDivideModuloExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-MultiplyDivideModuloExpressionContext.prototype.constructor = MultiplyDivideModuloExpressionContext
-
-MultiplyDivideModuloExpressionContext.prototype.powerOfExpression = function(
-  i
-) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PowerOfExpressionContext)
-  } else {
-    return this.getTypedRuleContext(PowerOfExpressionContext, i)
-  }
-}
-
-MultiplyDivideModuloExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-MultiplyDivideModuloExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterMultiplyDivideModuloExpression(this)
-  }
-}
-
-MultiplyDivideModuloExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitMultiplyDivideModuloExpression(this)
-  }
-}
-
-CypherParser.MultiplyDivideModuloExpressionContext = MultiplyDivideModuloExpressionContext
-
-CypherParser.prototype.multiplyDivideModuloExpression = function() {
-  var localctx = new MultiplyDivideModuloExpressionContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    270,
-    CypherParser.RULE_multiplyDivideModuloExpression
-  )
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1890
-    this.powerOfExpression()
-    this.state = 1917
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 268, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1915
-        this._errHandler.sync(this)
-        var la_ = this._interp.adaptivePredict(this._input, 267, this._ctx)
-        switch (la_) {
-          case 1:
-            this.state = 1892
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1891
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1894
-            this.match(CypherParser.T__22)
-            this.state = 1896
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1895
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1898
-            this.powerOfExpression()
-            break
-
-          case 2:
-            this.state = 1900
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1899
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1902
-            this.match(CypherParser.T__5)
-            this.state = 1904
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1903
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1906
-            this.powerOfExpression()
-            break
-
-          case 3:
-            this.state = 1908
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1907
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1910
-            this.match(CypherParser.T__24)
-            this.state = 1912
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1911
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1914
-            this.powerOfExpression()
-            break
-        }
-      }
-      this.state = 1919
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 268, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PowerOfExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_powerOfExpression
-  return this
-}
-
-PowerOfExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PowerOfExpressionContext.prototype.constructor = PowerOfExpressionContext
-
-PowerOfExpressionContext.prototype.unaryAddOrSubtractExpression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(UnaryAddOrSubtractExpressionContext)
-  } else {
-    return this.getTypedRuleContext(UnaryAddOrSubtractExpressionContext, i)
-  }
-}
-
-PowerOfExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PowerOfExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPowerOfExpression(this)
-  }
-}
-
-PowerOfExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPowerOfExpression(this)
-  }
-}
-
-CypherParser.PowerOfExpressionContext = PowerOfExpressionContext
-
-CypherParser.prototype.powerOfExpression = function() {
-  var localctx = new PowerOfExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 272, CypherParser.RULE_powerOfExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1920
-    this.unaryAddOrSubtractExpression()
-    this.state = 1931
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 271, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1922
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1921
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1924
-        this.match(CypherParser.T__25)
-        this.state = 1926
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 1925
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 1928
-        this.unaryAddOrSubtractExpression()
-      }
-      this.state = 1933
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 271, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function UnaryAddOrSubtractExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_unaryAddOrSubtractExpression
-  return this
-}
-
-UnaryAddOrSubtractExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-UnaryAddOrSubtractExpressionContext.prototype.constructor = UnaryAddOrSubtractExpressionContext
-
-UnaryAddOrSubtractExpressionContext.prototype.stringListNullOperatorExpression = function() {
-  return this.getTypedRuleContext(StringListNullOperatorExpressionContext, 0)
-}
-
-UnaryAddOrSubtractExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-UnaryAddOrSubtractExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterUnaryAddOrSubtractExpression(this)
-  }
-}
-
-UnaryAddOrSubtractExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitUnaryAddOrSubtractExpression(this)
-  }
-}
-
-CypherParser.UnaryAddOrSubtractExpressionContext = UnaryAddOrSubtractExpressionContext
-
-CypherParser.prototype.unaryAddOrSubtractExpression = function() {
-  var localctx = new UnaryAddOrSubtractExpressionContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 274, CypherParser.RULE_unaryAddOrSubtractExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1940
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    while (_la === CypherParser.T__2 || _la === CypherParser.T__12) {
-      this.state = 1934
-      _la = this._input.LA(1)
-      if (!(_la === CypherParser.T__2 || _la === CypherParser.T__12)) {
-        this._errHandler.recoverInline(this)
-      } else {
-        this._errHandler.reportMatch(this)
-        this.consume()
-      }
-      this.state = 1936
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 1935
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 1942
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-    }
-    this.state = 1943
-    this.stringListNullOperatorExpression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function StringListNullOperatorExpressionContext(
-  parser,
-  parent,
-  invokingState
-) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_stringListNullOperatorExpression
-  return this
-}
-
-StringListNullOperatorExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-StringListNullOperatorExpressionContext.prototype.constructor = StringListNullOperatorExpressionContext
-
-StringListNullOperatorExpressionContext.prototype.propertyOrLabelsExpression = function(
-  i
-) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PropertyOrLabelsExpressionContext)
-  } else {
-    return this.getTypedRuleContext(PropertyOrLabelsExpressionContext, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.IS = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.IS)
-  } else {
-    return this.getToken(CypherParser.IS, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.NULL = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.NULL)
-  } else {
-    return this.getToken(CypherParser.NULL, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.NOT = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.NOT)
-  } else {
-    return this.getToken(CypherParser.NOT, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.IN = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.IN)
-  } else {
-    return this.getToken(CypherParser.IN, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.STARTS = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.STARTS)
-  } else {
-    return this.getToken(CypherParser.STARTS, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.WITH = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.WITH)
-  } else {
-    return this.getToken(CypherParser.WITH, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.ENDS = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.ENDS)
-  } else {
-    return this.getToken(CypherParser.ENDS, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.CONTAINS = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.CONTAINS)
-  } else {
-    return this.getToken(CypherParser.CONTAINS, i)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.enterRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.enterStringListNullOperatorExpression(this)
-  }
-}
-
-StringListNullOperatorExpressionContext.prototype.exitRule = function(
-  listener
-) {
-  if (listener instanceof CypherListener) {
-    listener.exitStringListNullOperatorExpression(this)
-  }
-}
-
-CypherParser.StringListNullOperatorExpressionContext = StringListNullOperatorExpressionContext
-
-CypherParser.prototype.stringListNullOperatorExpression = function() {
-  var localctx = new StringListNullOperatorExpressionContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(
-    localctx,
-    276,
-    CypherParser.RULE_stringListNullOperatorExpression
-  )
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 1945
-    this.propertyOrLabelsExpression()
-    this.state = 1999
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 282, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 1997
-        this._errHandler.sync(this)
-        var la_ = this._interp.adaptivePredict(this._input, 281, this._ctx)
-        switch (la_) {
-          case 1:
-            this.state = 1947
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1946
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1949
-            this.match(CypherParser.T__16)
-            this.state = 1950
-            this.expression()
-            this.state = 1951
-            this.match(CypherParser.T__17)
-            break
-
-          case 2:
-            this.state = 1954
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1953
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1956
-            this.match(CypherParser.T__16)
-            this.state = 1958
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (
-              ((_la & ~0x1f) == 0 &&
-                ((1 << _la) &
-                  ((1 << CypherParser.T__2) |
-                    (1 << CypherParser.T__12) |
-                    (1 << CypherParser.T__13) |
-                    (1 << CypherParser.T__16) |
-                    (1 << CypherParser.T__18))) !==
-                  0) ||
-              (((_la - 34) & ~0x1f) == 0 &&
-                ((1 << (_la - 34)) &
-                  ((1 << (CypherParser.T__33 - 34)) |
-                    (1 << (CypherParser.CYPHER - 34)) |
-                    (1 << (CypherParser.EXPLAIN - 34)) |
-                    (1 << (CypherParser.PROFILE - 34)) |
-                    (1 << (CypherParser.USING - 34)) |
-                    (1 << (CypherParser.PERIODIC - 34)) |
-                    (1 << (CypherParser.COMMIT - 34)) |
-                    (1 << (CypherParser.UNION - 34)) |
-                    (1 << (CypherParser.ALL - 34)) |
-                    (1 << (CypherParser.CREATE - 34)) |
-                    (1 << (CypherParser.DROP - 34)) |
-                    (1 << (CypherParser.INDEX - 34)) |
-                    (1 << (CypherParser.ON - 34)))) !==
-                  0) ||
-              (((_la - 66) & ~0x1f) == 0 &&
-                ((1 << (_la - 66)) &
-                  ((1 << (CypherParser.CONSTRAINT - 66)) |
-                    (1 << (CypherParser.ASSERT - 66)) |
-                    (1 << (CypherParser.IS - 66)) |
-                    (1 << (CypherParser.UNIQUE - 66)) |
-                    (1 << (CypherParser.EXISTS - 66)) |
-                    (1 << (CypherParser.LOAD - 66)) |
-                    (1 << (CypherParser.CSV - 66)) |
-                    (1 << (CypherParser.WITH - 66)) |
-                    (1 << (CypherParser.HEADERS - 66)) |
-                    (1 << (CypherParser.FROM - 66)) |
-                    (1 << (CypherParser.AS - 66)) |
-                    (1 << (CypherParser.FIELDTERMINATOR - 66)) |
-                    (1 << (CypherParser.OPTIONAL - 66)) |
-                    (1 << (CypherParser.MATCH - 66)) |
-                    (1 << (CypherParser.UNWIND - 66)) |
-                    (1 << (CypherParser.MERGE - 66)) |
-                    (1 << (CypherParser.SET - 66)) |
-                    (1 << (CypherParser.DETACH - 66)) |
-                    (1 << (CypherParser.DELETE - 66)) |
-                    (1 << (CypherParser.REMOVE - 66)) |
-                    (1 << (CypherParser.FOREACH - 66)) |
-                    (1 << (CypherParser.IN - 66)) |
-                    (1 << (CypherParser.DISTINCT - 66)) |
-                    (1 << (CypherParser.RETURN - 66)) |
-                    (1 << (CypherParser.ORDER - 66)) |
-                    (1 << (CypherParser.BY - 66)) |
-                    (1 << (CypherParser.L_SKIP - 66)) |
-                    (1 << (CypherParser.LIMIT - 66)) |
-                    (1 << (CypherParser.ASCENDING - 66)) |
-                    (1 << (CypherParser.ASC - 66)) |
-                    (1 << (CypherParser.DESCENDING - 66)) |
-                    (1 << (CypherParser.DESC - 66)))) !==
-                  0) ||
-              (((_la - 98) & ~0x1f) == 0 &&
-                ((1 << (_la - 98)) &
-                  ((1 << (CypherParser.JOIN - 98)) |
-                    (1 << (CypherParser.SCAN - 98)) |
-                    (1 << (CypherParser.START - 98)) |
-                    (1 << (CypherParser.NODE - 98)) |
-                    (1 << (CypherParser.RELATIONSHIP - 98)) |
-                    (1 << (CypherParser.REL - 98)) |
-                    (1 << (CypherParser.WHERE - 98)) |
-                    (1 << (CypherParser.SHORTESTPATH - 98)) |
-                    (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
-                    (1 << (CypherParser.OR - 98)) |
-                    (1 << (CypherParser.XOR - 98)) |
-                    (1 << (CypherParser.AND - 98)) |
-                    (1 << (CypherParser.NOT - 98)) |
-                    (1 << (CypherParser.STARTS - 98)) |
-                    (1 << (CypherParser.ENDS - 98)) |
-                    (1 << (CypherParser.CONTAINS - 98)) |
-                    (1 << (CypherParser.NULL - 98)) |
-                    (1 << (CypherParser.COUNT - 98)) |
-                    (1 << (CypherParser.FILTER - 98)) |
-                    (1 << (CypherParser.EXTRACT - 98)) |
-                    (1 << (CypherParser.ANY - 98)) |
-                    (1 << (CypherParser.NONE - 98)) |
-                    (1 << (CypherParser.SINGLE - 98)) |
-                    (1 << (CypherParser.TRUE - 98)) |
-                    (1 << (CypherParser.FALSE - 98)) |
-                    (1 << (CypherParser.REDUCE - 98)) |
-                    (1 << (CypherParser.CASE - 98)) |
-                    (1 << (CypherParser.ELSE - 98)) |
-                    (1 << (CypherParser.END - 98)) |
-                    (1 << (CypherParser.WHEN - 98)) |
-                    (1 << (CypherParser.THEN - 98)) |
-                    (1 << (CypherParser.CALL - 98)))) !==
-                  0) ||
-              (((_la - 130) & ~0x1f) == 0 &&
-                ((1 << (_la - 130)) &
-                  ((1 << (CypherParser.YIELD - 130)) |
-                    (1 << (CypherParser.KEY - 130)) |
-                    (1 << (CypherParser.StringLiteral - 130)) |
-                    (1 << (CypherParser.HexInteger - 130)) |
-                    (1 << (CypherParser.DecimalInteger - 130)) |
-                    (1 << (CypherParser.OctalInteger - 130)) |
-                    (1 << (CypherParser.HexLetter - 130)) |
-                    (1 << (CypherParser.ExponentDecimalReal - 130)) |
-                    (1 << (CypherParser.RegularDecimalReal - 130)) |
-                    (1 << (CypherParser.UnescapedSymbolicName - 130)) |
-                    (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
-                  0)
-            ) {
-              this.state = 1957
-              this.expression()
-            }
-
-            this.state = 1960
-            this.match(CypherParser.T__23)
-            this.state = 1962
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (
-              ((_la & ~0x1f) == 0 &&
-                ((1 << _la) &
-                  ((1 << CypherParser.T__2) |
-                    (1 << CypherParser.T__12) |
-                    (1 << CypherParser.T__13) |
-                    (1 << CypherParser.T__16) |
-                    (1 << CypherParser.T__18))) !==
-                  0) ||
-              (((_la - 34) & ~0x1f) == 0 &&
-                ((1 << (_la - 34)) &
-                  ((1 << (CypherParser.T__33 - 34)) |
-                    (1 << (CypherParser.CYPHER - 34)) |
-                    (1 << (CypherParser.EXPLAIN - 34)) |
-                    (1 << (CypherParser.PROFILE - 34)) |
-                    (1 << (CypherParser.USING - 34)) |
-                    (1 << (CypherParser.PERIODIC - 34)) |
-                    (1 << (CypherParser.COMMIT - 34)) |
-                    (1 << (CypherParser.UNION - 34)) |
-                    (1 << (CypherParser.ALL - 34)) |
-                    (1 << (CypherParser.CREATE - 34)) |
-                    (1 << (CypherParser.DROP - 34)) |
-                    (1 << (CypherParser.INDEX - 34)) |
-                    (1 << (CypherParser.ON - 34)))) !==
-                  0) ||
-              (((_la - 66) & ~0x1f) == 0 &&
-                ((1 << (_la - 66)) &
-                  ((1 << (CypherParser.CONSTRAINT - 66)) |
-                    (1 << (CypherParser.ASSERT - 66)) |
-                    (1 << (CypherParser.IS - 66)) |
-                    (1 << (CypherParser.UNIQUE - 66)) |
-                    (1 << (CypherParser.EXISTS - 66)) |
-                    (1 << (CypherParser.LOAD - 66)) |
-                    (1 << (CypherParser.CSV - 66)) |
-                    (1 << (CypherParser.WITH - 66)) |
-                    (1 << (CypherParser.HEADERS - 66)) |
-                    (1 << (CypherParser.FROM - 66)) |
-                    (1 << (CypherParser.AS - 66)) |
-                    (1 << (CypherParser.FIELDTERMINATOR - 66)) |
-                    (1 << (CypherParser.OPTIONAL - 66)) |
-                    (1 << (CypherParser.MATCH - 66)) |
-                    (1 << (CypherParser.UNWIND - 66)) |
-                    (1 << (CypherParser.MERGE - 66)) |
-                    (1 << (CypherParser.SET - 66)) |
-                    (1 << (CypherParser.DETACH - 66)) |
-                    (1 << (CypherParser.DELETE - 66)) |
-                    (1 << (CypherParser.REMOVE - 66)) |
-                    (1 << (CypherParser.FOREACH - 66)) |
-                    (1 << (CypherParser.IN - 66)) |
-                    (1 << (CypherParser.DISTINCT - 66)) |
-                    (1 << (CypherParser.RETURN - 66)) |
-                    (1 << (CypherParser.ORDER - 66)) |
-                    (1 << (CypherParser.BY - 66)) |
-                    (1 << (CypherParser.L_SKIP - 66)) |
-                    (1 << (CypherParser.LIMIT - 66)) |
-                    (1 << (CypherParser.ASCENDING - 66)) |
-                    (1 << (CypherParser.ASC - 66)) |
-                    (1 << (CypherParser.DESCENDING - 66)) |
-                    (1 << (CypherParser.DESC - 66)))) !==
-                  0) ||
-              (((_la - 98) & ~0x1f) == 0 &&
-                ((1 << (_la - 98)) &
-                  ((1 << (CypherParser.JOIN - 98)) |
-                    (1 << (CypherParser.SCAN - 98)) |
-                    (1 << (CypherParser.START - 98)) |
-                    (1 << (CypherParser.NODE - 98)) |
-                    (1 << (CypherParser.RELATIONSHIP - 98)) |
-                    (1 << (CypherParser.REL - 98)) |
-                    (1 << (CypherParser.WHERE - 98)) |
-                    (1 << (CypherParser.SHORTESTPATH - 98)) |
-                    (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
-                    (1 << (CypherParser.OR - 98)) |
-                    (1 << (CypherParser.XOR - 98)) |
-                    (1 << (CypherParser.AND - 98)) |
-                    (1 << (CypherParser.NOT - 98)) |
-                    (1 << (CypherParser.STARTS - 98)) |
-                    (1 << (CypherParser.ENDS - 98)) |
-                    (1 << (CypherParser.CONTAINS - 98)) |
-                    (1 << (CypherParser.NULL - 98)) |
-                    (1 << (CypherParser.COUNT - 98)) |
-                    (1 << (CypherParser.FILTER - 98)) |
-                    (1 << (CypherParser.EXTRACT - 98)) |
-                    (1 << (CypherParser.ANY - 98)) |
-                    (1 << (CypherParser.NONE - 98)) |
-                    (1 << (CypherParser.SINGLE - 98)) |
-                    (1 << (CypherParser.TRUE - 98)) |
-                    (1 << (CypherParser.FALSE - 98)) |
-                    (1 << (CypherParser.REDUCE - 98)) |
-                    (1 << (CypherParser.CASE - 98)) |
-                    (1 << (CypherParser.ELSE - 98)) |
-                    (1 << (CypherParser.END - 98)) |
-                    (1 << (CypherParser.WHEN - 98)) |
-                    (1 << (CypherParser.THEN - 98)) |
-                    (1 << (CypherParser.CALL - 98)))) !==
-                  0) ||
-              (((_la - 130) & ~0x1f) == 0 &&
-                ((1 << (_la - 130)) &
-                  ((1 << (CypherParser.YIELD - 130)) |
-                    (1 << (CypherParser.KEY - 130)) |
-                    (1 << (CypherParser.StringLiteral - 130)) |
-                    (1 << (CypherParser.HexInteger - 130)) |
-                    (1 << (CypherParser.DecimalInteger - 130)) |
-                    (1 << (CypherParser.OctalInteger - 130)) |
-                    (1 << (CypherParser.HexLetter - 130)) |
-                    (1 << (CypherParser.ExponentDecimalReal - 130)) |
-                    (1 << (CypherParser.RegularDecimalReal - 130)) |
-                    (1 << (CypherParser.UnescapedSymbolicName - 130)) |
-                    (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
-                  0)
-            ) {
-              this.state = 1961
-              this.expression()
-            }
-
-            this.state = 1964
-            this.match(CypherParser.T__17)
-            break
-
-          case 3:
-            this.state = 1981
-            this._errHandler.sync(this)
-            var la_ = this._interp.adaptivePredict(this._input, 279, this._ctx)
-            switch (la_) {
-              case 1:
-                this.state = 1966
-                this._errHandler.sync(this)
-                _la = this._input.LA(1)
-                if (_la === CypherParser.SP) {
-                  this.state = 1965
-                  this.match(CypherParser.SP)
-                }
-
-                this.state = 1968
-                this.match(CypherParser.T__26)
-                break
-
-              case 2:
-                this.state = 1969
-                this.match(CypherParser.SP)
-                this.state = 1970
-                this.match(CypherParser.IN)
-                break
-
-              case 3:
-                this.state = 1971
-                this.match(CypherParser.SP)
-                this.state = 1972
-                this.match(CypherParser.STARTS)
-                this.state = 1973
-                this.match(CypherParser.SP)
-                this.state = 1974
-                this.match(CypherParser.WITH)
-                break
-
-              case 4:
-                this.state = 1975
-                this.match(CypherParser.SP)
-                this.state = 1976
-                this.match(CypherParser.ENDS)
-                this.state = 1977
-                this.match(CypherParser.SP)
-                this.state = 1978
-                this.match(CypherParser.WITH)
-                break
-
-              case 5:
-                this.state = 1979
-                this.match(CypherParser.SP)
-                this.state = 1980
-                this.match(CypherParser.CONTAINS)
-                break
-            }
-            this.state = 1984
-            this._errHandler.sync(this)
-            _la = this._input.LA(1)
-            if (_la === CypherParser.SP) {
-              this.state = 1983
-              this.match(CypherParser.SP)
-            }
-
-            this.state = 1986
-            this.propertyOrLabelsExpression()
-            break
-
-          case 4:
-            this.state = 1987
-            this.match(CypherParser.SP)
-            this.state = 1988
-            this.match(CypherParser.IS)
-            this.state = 1989
-            this.match(CypherParser.SP)
-            this.state = 1990
-            this.match(CypherParser.NULL)
-            break
-
-          case 5:
-            this.state = 1991
-            this.match(CypherParser.SP)
-            this.state = 1992
-            this.match(CypherParser.IS)
-            this.state = 1993
-            this.match(CypherParser.SP)
-            this.state = 1994
-            this.match(CypherParser.NOT)
-            this.state = 1995
-            this.match(CypherParser.SP)
-            this.state = 1996
-            this.match(CypherParser.NULL)
-            break
-        }
-      }
-      this.state = 2001
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 282, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertyOrLabelsExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_propertyOrLabelsExpression
-  return this
-}
-
-PropertyOrLabelsExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PropertyOrLabelsExpressionContext.prototype.constructor = PropertyOrLabelsExpressionContext
-
-PropertyOrLabelsExpressionContext.prototype.atom = function() {
-  return this.getTypedRuleContext(AtomContext, 0)
-}
-
-PropertyOrLabelsExpressionContext.prototype.propertyLookup = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PropertyLookupContext)
-  } else {
-    return this.getTypedRuleContext(PropertyLookupContext, i)
-  }
-}
-
-PropertyOrLabelsExpressionContext.prototype.nodeLabels = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(NodeLabelsContext)
-  } else {
-    return this.getTypedRuleContext(NodeLabelsContext, i)
-  }
-}
-
-PropertyOrLabelsExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PropertyOrLabelsExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPropertyOrLabelsExpression(this)
-  }
-}
-
-PropertyOrLabelsExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPropertyOrLabelsExpression(this)
-  }
-}
-
-CypherParser.PropertyOrLabelsExpressionContext = PropertyOrLabelsExpressionContext
-
-CypherParser.prototype.propertyOrLabelsExpression = function() {
-  var localctx = new PropertyOrLabelsExpressionContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 278, CypherParser.RULE_propertyOrLabelsExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2002
-    this.atom()
-    this.state = 2012
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 285, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 2004
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2003
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2008
-        this._errHandler.sync(this)
-        switch (this._input.LA(1)) {
-          case CypherParser.T__6:
-            this.state = 2006
-            this.propertyLookup()
-            break
-          case CypherParser.T__1:
-            this.state = 2007
-            this.nodeLabels()
-            break
-          default:
-            throw new antlr4.error.NoViableAltException(this)
-        }
-      }
-      this.state = 2014
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 285, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function FilterFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_filterFunction
-  return this
-}
-
-FilterFunctionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-FilterFunctionContext.prototype.constructor = FilterFunctionContext
-
-FilterFunctionContext.prototype.filterFunctionName = function() {
-  return this.getTypedRuleContext(FilterFunctionNameContext, 0)
-}
-
-FilterFunctionContext.prototype.filterExpression = function() {
-  return this.getTypedRuleContext(FilterExpressionContext, 0)
-}
-
-FilterFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-FilterFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterFilterFunction(this)
-  }
-}
-
-FilterFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitFilterFunction(this)
-  }
-}
-
-CypherParser.FilterFunctionContext = FilterFunctionContext
-
-CypherParser.prototype.filterFunction = function() {
-  var localctx = new FilterFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 280, CypherParser.RULE_filterFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2015
-    this.filterFunctionName()
-    this.state = 2017
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2016
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2019
-    this.match(CypherParser.T__18)
-    this.state = 2021
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2020
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2023
-    this.filterExpression()
-    this.state = 2025
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2024
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2027
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function FilterFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_filterFunctionName
-  return this
-}
-
-FilterFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-FilterFunctionNameContext.prototype.constructor = FilterFunctionNameContext
-
-FilterFunctionNameContext.prototype.FILTER = function() {
-  return this.getToken(CypherParser.FILTER, 0)
-}
-
-FilterFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterFilterFunctionName(this)
-  }
-}
-
-FilterFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitFilterFunctionName(this)
-  }
-}
-
-CypherParser.FilterFunctionNameContext = FilterFunctionNameContext
-
-CypherParser.prototype.filterFunctionName = function() {
-  var localctx = new FilterFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 282, CypherParser.RULE_filterFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2029
-    this.match(CypherParser.FILTER)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ExistsFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_existsFunction
-  return this
-}
-
-ExistsFunctionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ExistsFunctionContext.prototype.constructor = ExistsFunctionContext
-
-ExistsFunctionContext.prototype.existsFunctionName = function() {
-  return this.getTypedRuleContext(ExistsFunctionNameContext, 0)
-}
-
-ExistsFunctionContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-ExistsFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ExistsFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterExistsFunction(this)
-  }
-}
-
-ExistsFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitExistsFunction(this)
-  }
-}
-
-CypherParser.ExistsFunctionContext = ExistsFunctionContext
-
-CypherParser.prototype.existsFunction = function() {
-  var localctx = new ExistsFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 284, CypherParser.RULE_existsFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2031
-    this.existsFunctionName()
-    this.state = 2033
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2032
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2035
-    this.match(CypherParser.T__18)
-    this.state = 2037
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2036
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2039
-    this.expression()
-    this.state = 2041
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2040
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2043
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ExistsFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_existsFunctionName
-  return this
-}
-
-ExistsFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ExistsFunctionNameContext.prototype.constructor = ExistsFunctionNameContext
-
-ExistsFunctionNameContext.prototype.EXISTS = function() {
-  return this.getToken(CypherParser.EXISTS, 0)
-}
-
-ExistsFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterExistsFunctionName(this)
-  }
-}
-
-ExistsFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitExistsFunctionName(this)
-  }
-}
-
-CypherParser.ExistsFunctionNameContext = ExistsFunctionNameContext
-
-CypherParser.prototype.existsFunctionName = function() {
-  var localctx = new ExistsFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 286, CypherParser.RULE_existsFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2045
-    this.match(CypherParser.EXISTS)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AllFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_allFunction
-  return this
-}
-
-AllFunctionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-AllFunctionContext.prototype.constructor = AllFunctionContext
-
-AllFunctionContext.prototype.allFunctionName = function() {
-  return this.getTypedRuleContext(AllFunctionNameContext, 0)
-}
-
-AllFunctionContext.prototype.filterExpression = function() {
-  return this.getTypedRuleContext(FilterExpressionContext, 0)
-}
-
-AllFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-AllFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAllFunction(this)
-  }
-}
-
-AllFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAllFunction(this)
-  }
-}
-
-CypherParser.AllFunctionContext = AllFunctionContext
-
-CypherParser.prototype.allFunction = function() {
-  var localctx = new AllFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 288, CypherParser.RULE_allFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2047
-    this.allFunctionName()
-    this.state = 2049
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2048
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2051
-    this.match(CypherParser.T__18)
-    this.state = 2053
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2052
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2055
-    this.filterExpression()
-    this.state = 2057
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2056
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2059
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AllFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_allFunctionName
-  return this
-}
-
-AllFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AllFunctionNameContext.prototype.constructor = AllFunctionNameContext
-
-AllFunctionNameContext.prototype.ALL = function() {
-  return this.getToken(CypherParser.ALL, 0)
-}
-
-AllFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAllFunctionName(this)
-  }
-}
-
-AllFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAllFunctionName(this)
-  }
-}
-
-CypherParser.AllFunctionNameContext = AllFunctionNameContext
-
-CypherParser.prototype.allFunctionName = function() {
-  var localctx = new AllFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 290, CypherParser.RULE_allFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2061
-    this.match(CypherParser.ALL)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AnyFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_anyFunction
-  return this
-}
-
-AnyFunctionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-AnyFunctionContext.prototype.constructor = AnyFunctionContext
-
-AnyFunctionContext.prototype.anyFunctionName = function() {
-  return this.getTypedRuleContext(AnyFunctionNameContext, 0)
-}
-
-AnyFunctionContext.prototype.filterExpression = function() {
-  return this.getTypedRuleContext(FilterExpressionContext, 0)
-}
-
-AnyFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-AnyFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAnyFunction(this)
-  }
-}
-
-AnyFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAnyFunction(this)
-  }
-}
-
-CypherParser.AnyFunctionContext = AnyFunctionContext
-
-CypherParser.prototype.anyFunction = function() {
-  var localctx = new AnyFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 292, CypherParser.RULE_anyFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2063
-    this.anyFunctionName()
-    this.state = 2065
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2064
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2067
-    this.match(CypherParser.T__18)
-    this.state = 2069
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2068
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2071
-    this.filterExpression()
-    this.state = 2073
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2072
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2075
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AnyFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_anyFunctionName
-  return this
-}
-
-AnyFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AnyFunctionNameContext.prototype.constructor = AnyFunctionNameContext
-
-AnyFunctionNameContext.prototype.ANY = function() {
-  return this.getToken(CypherParser.ANY, 0)
-}
-
-AnyFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAnyFunctionName(this)
-  }
-}
-
-AnyFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAnyFunctionName(this)
-  }
-}
-
-CypherParser.AnyFunctionNameContext = AnyFunctionNameContext
-
-CypherParser.prototype.anyFunctionName = function() {
-  var localctx = new AnyFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 294, CypherParser.RULE_anyFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2077
-    this.match(CypherParser.ANY)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NoneFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_noneFunction
-  return this
-}
-
-NoneFunctionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-NoneFunctionContext.prototype.constructor = NoneFunctionContext
-
-NoneFunctionContext.prototype.noneFunctionName = function() {
-  return this.getTypedRuleContext(NoneFunctionNameContext, 0)
-}
-
-NoneFunctionContext.prototype.filterExpression = function() {
-  return this.getTypedRuleContext(FilterExpressionContext, 0)
-}
-
-NoneFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-NoneFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNoneFunction(this)
-  }
-}
-
-NoneFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNoneFunction(this)
-  }
-}
-
-CypherParser.NoneFunctionContext = NoneFunctionContext
-
-CypherParser.prototype.noneFunction = function() {
-  var localctx = new NoneFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 296, CypherParser.RULE_noneFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2079
-    this.noneFunctionName()
-    this.state = 2081
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2080
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2083
-    this.match(CypherParser.T__18)
-    this.state = 2085
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2084
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2087
-    this.filterExpression()
-    this.state = 2089
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2088
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2091
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NoneFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_noneFunctionName
-  return this
-}
-
-NoneFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-NoneFunctionNameContext.prototype.constructor = NoneFunctionNameContext
-
-NoneFunctionNameContext.prototype.NONE = function() {
-  return this.getToken(CypherParser.NONE, 0)
-}
-
-NoneFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNoneFunctionName(this)
-  }
-}
-
-NoneFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNoneFunctionName(this)
-  }
-}
-
-CypherParser.NoneFunctionNameContext = NoneFunctionNameContext
-
-CypherParser.prototype.noneFunctionName = function() {
-  var localctx = new NoneFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 298, CypherParser.RULE_noneFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2093
-    this.match(CypherParser.NONE)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SingleFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_singleFunction
-  return this
-}
-
-SingleFunctionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-SingleFunctionContext.prototype.constructor = SingleFunctionContext
-
-SingleFunctionContext.prototype.singleFunctionName = function() {
-  return this.getTypedRuleContext(SingleFunctionNameContext, 0)
-}
-
-SingleFunctionContext.prototype.filterExpression = function() {
-  return this.getTypedRuleContext(FilterExpressionContext, 0)
-}
-
-SingleFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-SingleFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSingleFunction(this)
-  }
-}
-
-SingleFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSingleFunction(this)
-  }
-}
-
-CypherParser.SingleFunctionContext = SingleFunctionContext
-
-CypherParser.prototype.singleFunction = function() {
-  var localctx = new SingleFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 300, CypherParser.RULE_singleFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2095
-    this.singleFunctionName()
-    this.state = 2097
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2096
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2099
-    this.match(CypherParser.T__18)
-    this.state = 2101
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2100
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2103
-    this.filterExpression()
-    this.state = 2105
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2104
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2107
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SingleFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_singleFunctionName
-  return this
-}
-
-SingleFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-SingleFunctionNameContext.prototype.constructor = SingleFunctionNameContext
-
-SingleFunctionNameContext.prototype.SINGLE = function() {
-  return this.getToken(CypherParser.SINGLE, 0)
-}
-
-SingleFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSingleFunctionName(this)
-  }
-}
-
-SingleFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSingleFunctionName(this)
-  }
-}
-
-CypherParser.SingleFunctionNameContext = SingleFunctionNameContext
-
-CypherParser.prototype.singleFunctionName = function() {
-  var localctx = new SingleFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 302, CypherParser.RULE_singleFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2109
-    this.match(CypherParser.SINGLE)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ExtractFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_extractFunction
-  return this
-}
-
-ExtractFunctionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ExtractFunctionContext.prototype.constructor = ExtractFunctionContext
-
-ExtractFunctionContext.prototype.extractFunctionName = function() {
-  return this.getTypedRuleContext(ExtractFunctionNameContext, 0)
-}
-
-ExtractFunctionContext.prototype.filterExpression = function() {
-  return this.getTypedRuleContext(FilterExpressionContext, 0)
-}
-
-ExtractFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ExtractFunctionContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-ExtractFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterExtractFunction(this)
-  }
-}
-
-ExtractFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitExtractFunction(this)
-  }
-}
-
-CypherParser.ExtractFunctionContext = ExtractFunctionContext
-
-CypherParser.prototype.extractFunction = function() {
-  var localctx = new ExtractFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 304, CypherParser.RULE_extractFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2111
-    this.extractFunctionName()
-    this.state = 2113
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2112
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2115
-    this.match(CypherParser.T__18)
-    this.state = 2117
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2116
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2119
-    this.filterExpression()
-    this.state = 2128
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 308, this._ctx)
-    if (la_ === 1) {
-      this.state = 2121
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2120
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2123
-      this.match(CypherParser.T__21)
-      this.state = 2125
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2124
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2127
-      this.expression()
-    }
-    this.state = 2131
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2130
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2133
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ExtractFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_extractFunctionName
-  return this
-}
-
-ExtractFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ExtractFunctionNameContext.prototype.constructor = ExtractFunctionNameContext
-
-ExtractFunctionNameContext.prototype.EXTRACT = function() {
-  return this.getToken(CypherParser.EXTRACT, 0)
-}
-
-ExtractFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterExtractFunctionName(this)
-  }
-}
-
-ExtractFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitExtractFunctionName(this)
-  }
-}
-
-CypherParser.ExtractFunctionNameContext = ExtractFunctionNameContext
-
-CypherParser.prototype.extractFunctionName = function() {
-  var localctx = new ExtractFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 306, CypherParser.RULE_extractFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2135
-    this.match(CypherParser.EXTRACT)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ReduceFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_reduceFunction
-  return this
-}
-
-ReduceFunctionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ReduceFunctionContext.prototype.constructor = ReduceFunctionContext
-
-ReduceFunctionContext.prototype.reduceFunctionName = function() {
-  return this.getTypedRuleContext(ReduceFunctionNameContext, 0)
-}
-
-ReduceFunctionContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-ReduceFunctionContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-ReduceFunctionContext.prototype.idInColl = function() {
-  return this.getTypedRuleContext(IdInCollContext, 0)
-}
-
-ReduceFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ReduceFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterReduceFunction(this)
-  }
-}
-
-ReduceFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitReduceFunction(this)
-  }
-}
-
-CypherParser.ReduceFunctionContext = ReduceFunctionContext
-
-CypherParser.prototype.reduceFunction = function() {
-  var localctx = new ReduceFunctionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 308, CypherParser.RULE_reduceFunction)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2137
-    this.reduceFunctionName()
-    this.state = 2139
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2138
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2141
-    this.match(CypherParser.T__18)
-    this.state = 2143
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2142
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2145
-    this.variable()
-    this.state = 2147
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2146
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2149
-    this.match(CypherParser.T__11)
-    this.state = 2151
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2150
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2153
-    this.expression()
-    this.state = 2155
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2154
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2157
-    this.match(CypherParser.T__14)
-    this.state = 2159
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2158
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2161
-    this.idInColl()
-    this.state = 2163
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2162
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2165
-    this.match(CypherParser.T__21)
-    this.state = 2167
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2166
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2169
-    this.expression()
-    this.state = 2171
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2170
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2173
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ReduceFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_reduceFunctionName
-  return this
-}
-
-ReduceFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ReduceFunctionNameContext.prototype.constructor = ReduceFunctionNameContext
-
-ReduceFunctionNameContext.prototype.REDUCE = function() {
-  return this.getToken(CypherParser.REDUCE, 0)
-}
-
-ReduceFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterReduceFunctionName(this)
-  }
-}
-
-ReduceFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitReduceFunctionName(this)
-  }
-}
-
-CypherParser.ReduceFunctionNameContext = ReduceFunctionNameContext
-
-CypherParser.prototype.reduceFunctionName = function() {
-  var localctx = new ReduceFunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 310, CypherParser.RULE_reduceFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2175
-    this.match(CypherParser.REDUCE)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ShortestPathPatternFunctionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_shortestPathPatternFunction
-  return this
-}
-
-ShortestPathPatternFunctionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ShortestPathPatternFunctionContext.prototype.constructor = ShortestPathPatternFunctionContext
-
-ShortestPathPatternFunctionContext.prototype.shortestPathFunctionName = function() {
-  return this.getTypedRuleContext(ShortestPathFunctionNameContext, 0)
-}
-
-ShortestPathPatternFunctionContext.prototype.patternElement = function() {
-  return this.getTypedRuleContext(PatternElementContext, 0)
-}
-
-ShortestPathPatternFunctionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ShortestPathPatternFunctionContext.prototype.allShortestPathFunctionName = function() {
-  return this.getTypedRuleContext(AllShortestPathFunctionNameContext, 0)
-}
-
-ShortestPathPatternFunctionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterShortestPathPatternFunction(this)
-  }
-}
-
-ShortestPathPatternFunctionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitShortestPathPatternFunction(this)
-  }
-}
-
-CypherParser.ShortestPathPatternFunctionContext = ShortestPathPatternFunctionContext
-
-CypherParser.prototype.shortestPathPatternFunction = function() {
-  var localctx = new ShortestPathPatternFunctionContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 312, CypherParser.RULE_shortestPathPatternFunction)
-  var _la = 0 // Token type
-  try {
-    this.state = 2205
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.SHORTESTPATH:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2177
-        this.shortestPathFunctionName()
-        this.state = 2179
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2178
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2181
-        this.match(CypherParser.T__18)
-        this.state = 2183
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2182
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2185
-        this.patternElement()
-        this.state = 2187
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2186
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2189
-        this.match(CypherParser.T__19)
-        break
-      case CypherParser.ALLSHORTESTPATHS:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2191
-        this.allShortestPathFunctionName()
-        this.state = 2193
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2192
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2195
-        this.match(CypherParser.T__18)
-        this.state = 2197
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2196
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2199
-        this.patternElement()
-        this.state = 2201
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2200
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2203
-        this.match(CypherParser.T__19)
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ShortestPathFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_shortestPathFunctionName
-  return this
-}
-
-ShortestPathFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ShortestPathFunctionNameContext.prototype.constructor = ShortestPathFunctionNameContext
-
-ShortestPathFunctionNameContext.prototype.SHORTESTPATH = function() {
-  return this.getToken(CypherParser.SHORTESTPATH, 0)
-}
-
-ShortestPathFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterShortestPathFunctionName(this)
-  }
-}
-
-ShortestPathFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitShortestPathFunctionName(this)
-  }
-}
-
-CypherParser.ShortestPathFunctionNameContext = ShortestPathFunctionNameContext
-
-CypherParser.prototype.shortestPathFunctionName = function() {
-  var localctx = new ShortestPathFunctionNameContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 314, CypherParser.RULE_shortestPathFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2207
-    this.match(CypherParser.SHORTESTPATH)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AllShortestPathFunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_allShortestPathFunctionName
-  return this
-}
-
-AllShortestPathFunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AllShortestPathFunctionNameContext.prototype.constructor = AllShortestPathFunctionNameContext
-
-AllShortestPathFunctionNameContext.prototype.ALLSHORTESTPATHS = function() {
-  return this.getToken(CypherParser.ALLSHORTESTPATHS, 0)
-}
-
-AllShortestPathFunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAllShortestPathFunctionName(this)
-  }
-}
-
-AllShortestPathFunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAllShortestPathFunctionName(this)
-  }
-}
-
-CypherParser.AllShortestPathFunctionNameContext = AllShortestPathFunctionNameContext
-
-CypherParser.prototype.allShortestPathFunctionName = function() {
-  var localctx = new AllShortestPathFunctionNameContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 316, CypherParser.RULE_allShortestPathFunctionName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2209
-    this.match(CypherParser.ALLSHORTESTPATHS)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AtomContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_atom
-  return this
-}
-
-AtomContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-AtomContext.prototype.constructor = AtomContext
-
-AtomContext.prototype.literal = function() {
-  return this.getTypedRuleContext(LiteralContext, 0)
-}
-
-AtomContext.prototype.parameter = function() {
-  return this.getTypedRuleContext(ParameterContext, 0)
-}
-
-AtomContext.prototype.caseExpression = function() {
-  return this.getTypedRuleContext(CaseExpressionContext, 0)
-}
-
-AtomContext.prototype.COUNT = function() {
-  return this.getToken(CypherParser.COUNT, 0)
-}
-
-AtomContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-AtomContext.prototype.listComprehension = function() {
-  return this.getTypedRuleContext(ListComprehensionContext, 0)
-}
-
-AtomContext.prototype.patternComprehension = function() {
-  return this.getTypedRuleContext(PatternComprehensionContext, 0)
-}
-
-AtomContext.prototype.filterFunction = function() {
-  return this.getTypedRuleContext(FilterFunctionContext, 0)
-}
-
-AtomContext.prototype.extractFunction = function() {
-  return this.getTypedRuleContext(ExtractFunctionContext, 0)
-}
-
-AtomContext.prototype.reduceFunction = function() {
-  return this.getTypedRuleContext(ReduceFunctionContext, 0)
-}
-
-AtomContext.prototype.allFunction = function() {
-  return this.getTypedRuleContext(AllFunctionContext, 0)
-}
-
-AtomContext.prototype.anyFunction = function() {
-  return this.getTypedRuleContext(AnyFunctionContext, 0)
-}
-
-AtomContext.prototype.noneFunction = function() {
-  return this.getTypedRuleContext(NoneFunctionContext, 0)
-}
-
-AtomContext.prototype.singleFunction = function() {
-  return this.getTypedRuleContext(SingleFunctionContext, 0)
-}
-
-AtomContext.prototype.existsFunction = function() {
-  return this.getTypedRuleContext(ExistsFunctionContext, 0)
-}
-
-AtomContext.prototype.shortestPathPatternFunction = function() {
-  return this.getTypedRuleContext(ShortestPathPatternFunctionContext, 0)
-}
-
-AtomContext.prototype.relationshipsPattern = function() {
-  return this.getTypedRuleContext(RelationshipsPatternContext, 0)
-}
-
-AtomContext.prototype.parenthesizedExpression = function() {
-  return this.getTypedRuleContext(ParenthesizedExpressionContext, 0)
-}
-
-AtomContext.prototype.functionInvocation = function() {
-  return this.getTypedRuleContext(FunctionInvocationContext, 0)
-}
-
-AtomContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-AtomContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAtom(this)
-  }
-}
-
-AtomContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAtom(this)
-  }
-}
-
-CypherParser.AtomContext = AtomContext
-
-CypherParser.prototype.atom = function() {
-  var localctx = new AtomContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 318, CypherParser.RULE_atom)
-  var _la = 0 // Token type
-  try {
-    this.state = 2242
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 329, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2211
-        this.literal()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2212
-        this.parameter()
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 2213
-        this.caseExpression()
-        break
-
-      case 4:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 2214
-        this.match(CypherParser.COUNT)
-        this.state = 2216
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2215
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2218
-        this.match(CypherParser.T__18)
-        this.state = 2220
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2219
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2222
-        this.match(CypherParser.T__22)
-        this.state = 2224
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2223
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2226
-        this.match(CypherParser.T__19)
-        break
-
-      case 5:
-        this.enterOuterAlt(localctx, 5)
-        this.state = 2227
-        this.listComprehension()
-        break
-
-      case 6:
-        this.enterOuterAlt(localctx, 6)
-        this.state = 2228
-        this.patternComprehension()
-        break
-
-      case 7:
-        this.enterOuterAlt(localctx, 7)
-        this.state = 2229
-        this.filterFunction()
-        break
-
-      case 8:
-        this.enterOuterAlt(localctx, 8)
-        this.state = 2230
-        this.extractFunction()
-        break
-
-      case 9:
-        this.enterOuterAlt(localctx, 9)
-        this.state = 2231
-        this.reduceFunction()
-        break
-
-      case 10:
-        this.enterOuterAlt(localctx, 10)
-        this.state = 2232
-        this.allFunction()
-        break
-
-      case 11:
-        this.enterOuterAlt(localctx, 11)
-        this.state = 2233
-        this.anyFunction()
-        break
-
-      case 12:
-        this.enterOuterAlt(localctx, 12)
-        this.state = 2234
-        this.noneFunction()
-        break
-
-      case 13:
-        this.enterOuterAlt(localctx, 13)
-        this.state = 2235
-        this.singleFunction()
-        break
-
-      case 14:
-        this.enterOuterAlt(localctx, 14)
-        this.state = 2236
-        this.existsFunction()
-        break
-
-      case 15:
-        this.enterOuterAlt(localctx, 15)
-        this.state = 2237
-        this.shortestPathPatternFunction()
-        break
-
-      case 16:
-        this.enterOuterAlt(localctx, 16)
-        this.state = 2238
-        this.relationshipsPattern()
-        break
-
-      case 17:
-        this.enterOuterAlt(localctx, 17)
-        this.state = 2239
-        this.parenthesizedExpression()
-        break
-
-      case 18:
-        this.enterOuterAlt(localctx, 18)
-        this.state = 2240
-        this.functionInvocation()
-        break
-
-      case 19:
-        this.enterOuterAlt(localctx, 19)
-        this.state = 2241
-        this.variable()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_literal
-  return this
-}
-
-LiteralContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-LiteralContext.prototype.constructor = LiteralContext
-
-LiteralContext.prototype.numberLiteral = function() {
-  return this.getTypedRuleContext(NumberLiteralContext, 0)
-}
-
-LiteralContext.prototype.stringLiteral = function() {
-  return this.getTypedRuleContext(StringLiteralContext, 0)
-}
-
-LiteralContext.prototype.booleanLiteral = function() {
-  return this.getTypedRuleContext(BooleanLiteralContext, 0)
-}
-
-LiteralContext.prototype.NULL = function() {
-  return this.getToken(CypherParser.NULL, 0)
-}
-
-LiteralContext.prototype.mapLiteral = function() {
-  return this.getTypedRuleContext(MapLiteralContext, 0)
-}
-
-LiteralContext.prototype.listLiteral = function() {
-  return this.getTypedRuleContext(ListLiteralContext, 0)
-}
-
-LiteralContext.prototype.mapProjection = function() {
-  return this.getTypedRuleContext(MapProjectionContext, 0)
-}
-
-LiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLiteral(this)
-  }
-}
-
-LiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLiteral(this)
-  }
-}
-
-CypherParser.LiteralContext = LiteralContext
-
-CypherParser.prototype.literal = function() {
-  var localctx = new LiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 320, CypherParser.RULE_literal)
-  try {
-    this.state = 2251
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 330, this._ctx)
-    switch (la_) {
-      case 1:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2244
-        this.numberLiteral()
-        break
-
-      case 2:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2245
-        this.stringLiteral()
-        break
-
-      case 3:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 2246
-        this.booleanLiteral()
-        break
-
-      case 4:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 2247
-        this.match(CypherParser.NULL)
-        break
-
-      case 5:
-        this.enterOuterAlt(localctx, 5)
-        this.state = 2248
-        this.mapLiteral()
-        break
-
-      case 6:
-        this.enterOuterAlt(localctx, 6)
-        this.state = 2249
-        this.listLiteral()
-        break
-
-      case 7:
-        this.enterOuterAlt(localctx, 7)
-        this.state = 2250
-        this.mapProjection()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function StringLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_stringLiteral
-  return this
-}
-
-StringLiteralContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-StringLiteralContext.prototype.constructor = StringLiteralContext
-
-StringLiteralContext.prototype.StringLiteral = function() {
-  return this.getToken(CypherParser.StringLiteral, 0)
-}
-
-StringLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterStringLiteral(this)
-  }
-}
-
-StringLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitStringLiteral(this)
-  }
-}
-
-CypherParser.StringLiteralContext = StringLiteralContext
-
-CypherParser.prototype.stringLiteral = function() {
-  var localctx = new StringLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 322, CypherParser.RULE_stringLiteral)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2253
-    this.match(CypherParser.StringLiteral)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function BooleanLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_booleanLiteral
-  return this
-}
-
-BooleanLiteralContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-BooleanLiteralContext.prototype.constructor = BooleanLiteralContext
-
-BooleanLiteralContext.prototype.TRUE = function() {
-  return this.getToken(CypherParser.TRUE, 0)
-}
-
-BooleanLiteralContext.prototype.FALSE = function() {
-  return this.getToken(CypherParser.FALSE, 0)
-}
-
-BooleanLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterBooleanLiteral(this)
-  }
-}
-
-BooleanLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitBooleanLiteral(this)
-  }
-}
-
-CypherParser.BooleanLiteralContext = BooleanLiteralContext
-
-CypherParser.prototype.booleanLiteral = function() {
-  var localctx = new BooleanLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 324, CypherParser.RULE_booleanLiteral)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2255
-    _la = this._input.LA(1)
-    if (!(_la === CypherParser.TRUE || _la === CypherParser.FALSE)) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ListLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_listLiteral
-  return this
-}
-
-ListLiteralContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ListLiteralContext.prototype.constructor = ListLiteralContext
-
-ListLiteralContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ListLiteralContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-ListLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterListLiteral(this)
-  }
-}
-
-ListLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitListLiteral(this)
-  }
-}
-
-CypherParser.ListLiteralContext = ListLiteralContext
-
-CypherParser.prototype.listLiteral = function() {
-  var localctx = new ListLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 326, CypherParser.RULE_listLiteral)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2257
-    this.match(CypherParser.T__16)
-    this.state = 2259
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2258
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2278
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      ((_la & ~0x1f) == 0 &&
-        ((1 << _la) &
-          ((1 << CypherParser.T__2) |
-            (1 << CypherParser.T__12) |
-            (1 << CypherParser.T__13) |
-            (1 << CypherParser.T__16) |
-            (1 << CypherParser.T__18))) !==
-          0) ||
-      (((_la - 34) & ~0x1f) == 0 &&
-        ((1 << (_la - 34)) &
-          ((1 << (CypherParser.T__33 - 34)) |
-            (1 << (CypherParser.CYPHER - 34)) |
-            (1 << (CypherParser.EXPLAIN - 34)) |
-            (1 << (CypherParser.PROFILE - 34)) |
-            (1 << (CypherParser.USING - 34)) |
-            (1 << (CypherParser.PERIODIC - 34)) |
-            (1 << (CypherParser.COMMIT - 34)) |
-            (1 << (CypherParser.UNION - 34)) |
-            (1 << (CypherParser.ALL - 34)) |
-            (1 << (CypherParser.CREATE - 34)) |
-            (1 << (CypherParser.DROP - 34)) |
-            (1 << (CypherParser.INDEX - 34)) |
-            (1 << (CypherParser.ON - 34)))) !==
-          0) ||
-      (((_la - 66) & ~0x1f) == 0 &&
-        ((1 << (_la - 66)) &
-          ((1 << (CypherParser.CONSTRAINT - 66)) |
-            (1 << (CypherParser.ASSERT - 66)) |
-            (1 << (CypherParser.IS - 66)) |
-            (1 << (CypherParser.UNIQUE - 66)) |
-            (1 << (CypherParser.EXISTS - 66)) |
-            (1 << (CypherParser.LOAD - 66)) |
-            (1 << (CypherParser.CSV - 66)) |
-            (1 << (CypherParser.WITH - 66)) |
-            (1 << (CypherParser.HEADERS - 66)) |
-            (1 << (CypherParser.FROM - 66)) |
-            (1 << (CypherParser.AS - 66)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 66)) |
-            (1 << (CypherParser.OPTIONAL - 66)) |
-            (1 << (CypherParser.MATCH - 66)) |
-            (1 << (CypherParser.UNWIND - 66)) |
-            (1 << (CypherParser.MERGE - 66)) |
-            (1 << (CypherParser.SET - 66)) |
-            (1 << (CypherParser.DETACH - 66)) |
-            (1 << (CypherParser.DELETE - 66)) |
-            (1 << (CypherParser.REMOVE - 66)) |
-            (1 << (CypherParser.FOREACH - 66)) |
-            (1 << (CypherParser.IN - 66)) |
-            (1 << (CypherParser.DISTINCT - 66)) |
-            (1 << (CypherParser.RETURN - 66)) |
-            (1 << (CypherParser.ORDER - 66)) |
-            (1 << (CypherParser.BY - 66)) |
-            (1 << (CypherParser.L_SKIP - 66)) |
-            (1 << (CypherParser.LIMIT - 66)) |
-            (1 << (CypherParser.ASCENDING - 66)) |
-            (1 << (CypherParser.ASC - 66)) |
-            (1 << (CypherParser.DESCENDING - 66)) |
-            (1 << (CypherParser.DESC - 66)))) !==
-          0) ||
-      (((_la - 98) & ~0x1f) == 0 &&
-        ((1 << (_la - 98)) &
-          ((1 << (CypherParser.JOIN - 98)) |
-            (1 << (CypherParser.SCAN - 98)) |
-            (1 << (CypherParser.START - 98)) |
-            (1 << (CypherParser.NODE - 98)) |
-            (1 << (CypherParser.RELATIONSHIP - 98)) |
-            (1 << (CypherParser.REL - 98)) |
-            (1 << (CypherParser.WHERE - 98)) |
-            (1 << (CypherParser.SHORTESTPATH - 98)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
-            (1 << (CypherParser.OR - 98)) |
-            (1 << (CypherParser.XOR - 98)) |
-            (1 << (CypherParser.AND - 98)) |
-            (1 << (CypherParser.NOT - 98)) |
-            (1 << (CypherParser.STARTS - 98)) |
-            (1 << (CypherParser.ENDS - 98)) |
-            (1 << (CypherParser.CONTAINS - 98)) |
-            (1 << (CypherParser.NULL - 98)) |
-            (1 << (CypherParser.COUNT - 98)) |
-            (1 << (CypherParser.FILTER - 98)) |
-            (1 << (CypherParser.EXTRACT - 98)) |
-            (1 << (CypherParser.ANY - 98)) |
-            (1 << (CypherParser.NONE - 98)) |
-            (1 << (CypherParser.SINGLE - 98)) |
-            (1 << (CypherParser.TRUE - 98)) |
-            (1 << (CypherParser.FALSE - 98)) |
-            (1 << (CypherParser.REDUCE - 98)) |
-            (1 << (CypherParser.CASE - 98)) |
-            (1 << (CypherParser.ELSE - 98)) |
-            (1 << (CypherParser.END - 98)) |
-            (1 << (CypherParser.WHEN - 98)) |
-            (1 << (CypherParser.THEN - 98)) |
-            (1 << (CypherParser.CALL - 98)))) !==
-          0) ||
-      (((_la - 130) & ~0x1f) == 0 &&
-        ((1 << (_la - 130)) &
-          ((1 << (CypherParser.YIELD - 130)) |
-            (1 << (CypherParser.KEY - 130)) |
-            (1 << (CypherParser.StringLiteral - 130)) |
-            (1 << (CypherParser.HexInteger - 130)) |
-            (1 << (CypherParser.DecimalInteger - 130)) |
-            (1 << (CypherParser.OctalInteger - 130)) |
-            (1 << (CypherParser.HexLetter - 130)) |
-            (1 << (CypherParser.ExponentDecimalReal - 130)) |
-            (1 << (CypherParser.RegularDecimalReal - 130)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 130)) |
-            (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
-          0)
-    ) {
-      this.state = 2261
-      this.expression()
-      this.state = 2263
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2262
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2275
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      while (_la === CypherParser.T__14) {
-        this.state = 2265
-        this.match(CypherParser.T__14)
-        this.state = 2267
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2266
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2269
-        this.expression()
-        this.state = 2271
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2270
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2277
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-      }
-    }
-
-    this.state = 2280
-    this.match(CypherParser.T__17)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PartialComparisonExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_partialComparisonExpression
-  return this
-}
-
-PartialComparisonExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PartialComparisonExpressionContext.prototype.constructor = PartialComparisonExpressionContext
-
-PartialComparisonExpressionContext.prototype.addOrSubtractExpression = function() {
-  return this.getTypedRuleContext(AddOrSubtractExpressionContext, 0)
-}
-
-PartialComparisonExpressionContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-PartialComparisonExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPartialComparisonExpression(this)
-  }
-}
-
-PartialComparisonExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPartialComparisonExpression(this)
-  }
-}
-
-CypherParser.PartialComparisonExpressionContext = PartialComparisonExpressionContext
-
-CypherParser.prototype.partialComparisonExpression = function() {
-  var localctx = new PartialComparisonExpressionContext(
-    this,
-    this._ctx,
-    this.state
-  )
-  this.enterRule(localctx, 328, CypherParser.RULE_partialComparisonExpression)
-  var _la = 0 // Token type
-  try {
-    this.state = 2317
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.T__11:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2282
-        this.match(CypherParser.T__11)
-        this.state = 2284
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2283
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2286
-        this.addOrSubtractExpression()
-        break
-      case CypherParser.T__27:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2287
-        this.match(CypherParser.T__27)
-        this.state = 2289
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2288
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2291
-        this.addOrSubtractExpression()
-        break
-      case CypherParser.T__28:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 2292
-        this.match(CypherParser.T__28)
-        this.state = 2294
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2293
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2296
-        this.addOrSubtractExpression()
-        break
-      case CypherParser.T__29:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 2297
-        this.match(CypherParser.T__29)
-        this.state = 2299
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2298
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2301
-        this.addOrSubtractExpression()
-        break
-      case CypherParser.T__30:
-        this.enterOuterAlt(localctx, 5)
-        this.state = 2302
-        this.match(CypherParser.T__30)
-        this.state = 2304
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2303
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2306
-        this.addOrSubtractExpression()
-        break
-      case CypherParser.T__31:
-        this.enterOuterAlt(localctx, 6)
-        this.state = 2307
-        this.match(CypherParser.T__31)
-        this.state = 2309
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2308
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2311
-        this.addOrSubtractExpression()
-        break
-      case CypherParser.T__32:
-        this.enterOuterAlt(localctx, 7)
-        this.state = 2312
-        this.match(CypherParser.T__32)
-        this.state = 2314
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2313
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2316
-        this.addOrSubtractExpression()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ParenthesizedExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_parenthesizedExpression
-  return this
-}
-
-ParenthesizedExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ParenthesizedExpressionContext.prototype.constructor = ParenthesizedExpressionContext
-
-ParenthesizedExpressionContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-ParenthesizedExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ParenthesizedExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterParenthesizedExpression(this)
-  }
-}
-
-ParenthesizedExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitParenthesizedExpression(this)
-  }
-}
-
-CypherParser.ParenthesizedExpressionContext = ParenthesizedExpressionContext
-
-CypherParser.prototype.parenthesizedExpression = function() {
-  var localctx = new ParenthesizedExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 330, CypherParser.RULE_parenthesizedExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2319
-    this.match(CypherParser.T__18)
-    this.state = 2321
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2320
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2323
-    this.expression()
-    this.state = 2325
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2324
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2327
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RelationshipsPatternContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_relationshipsPattern
-  return this
-}
-
-RelationshipsPatternContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RelationshipsPatternContext.prototype.constructor = RelationshipsPatternContext
-
-RelationshipsPatternContext.prototype.nodePattern = function() {
-  return this.getTypedRuleContext(NodePatternContext, 0)
-}
-
-RelationshipsPatternContext.prototype.patternElementChain = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PatternElementChainContext)
-  } else {
-    return this.getTypedRuleContext(PatternElementChainContext, i)
-  }
-}
-
-RelationshipsPatternContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-RelationshipsPatternContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRelationshipsPattern(this)
-  }
-}
-
-RelationshipsPatternContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRelationshipsPattern(this)
-  }
-}
-
-CypherParser.RelationshipsPatternContext = RelationshipsPatternContext
-
-CypherParser.prototype.relationshipsPattern = function() {
-  var localctx = new RelationshipsPatternContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 332, CypherParser.RULE_relationshipsPattern)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2329
-    this.nodePattern()
-    this.state = 2334
-    this._errHandler.sync(this)
-    var _alt = 1
-    do {
-      switch (_alt) {
-        case 1:
-          this.state = 2331
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-          if (_la === CypherParser.SP) {
-            this.state = 2330
-            this.match(CypherParser.SP)
-          }
-
-          this.state = 2333
-          this.patternElementChain()
-          break
-        default:
-          throw new antlr4.error.NoViableAltException(this)
-      }
-      this.state = 2336
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 348, this._ctx)
-    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function FilterExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_filterExpression
-  return this
-}
-
-FilterExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-FilterExpressionContext.prototype.constructor = FilterExpressionContext
-
-FilterExpressionContext.prototype.idInColl = function() {
-  return this.getTypedRuleContext(IdInCollContext, 0)
-}
-
-FilterExpressionContext.prototype.where = function() {
-  return this.getTypedRuleContext(WhereContext, 0)
-}
-
-FilterExpressionContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-FilterExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterFilterExpression(this)
-  }
-}
-
-FilterExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitFilterExpression(this)
-  }
-}
-
-CypherParser.FilterExpressionContext = FilterExpressionContext
-
-CypherParser.prototype.filterExpression = function() {
-  var localctx = new FilterExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 334, CypherParser.RULE_filterExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2338
-    this.idInColl()
-    this.state = 2343
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 350, this._ctx)
-    if (la_ === 1) {
-      this.state = 2340
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2339
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2342
-      this.where()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function IdInCollContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_idInColl
-  return this
-}
-
-IdInCollContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-IdInCollContext.prototype.constructor = IdInCollContext
-
-IdInCollContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-IdInCollContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-IdInCollContext.prototype.IN = function() {
-  return this.getToken(CypherParser.IN, 0)
-}
-
-IdInCollContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-IdInCollContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterIdInColl(this)
-  }
-}
-
-IdInCollContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitIdInColl(this)
-  }
-}
-
-CypherParser.IdInCollContext = IdInCollContext
-
-CypherParser.prototype.idInColl = function() {
-  var localctx = new IdInCollContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 336, CypherParser.RULE_idInColl)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2345
-    this.variable()
-    this.state = 2346
-    this.match(CypherParser.SP)
-    this.state = 2347
-    this.match(CypherParser.IN)
-    this.state = 2348
-    this.match(CypherParser.SP)
-    this.state = 2349
-    this.expression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function FunctionInvocationContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_functionInvocation
-  return this
-}
-
-FunctionInvocationContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-FunctionInvocationContext.prototype.constructor = FunctionInvocationContext
-
-FunctionInvocationContext.prototype.functionInvocationBody = function() {
-  return this.getTypedRuleContext(FunctionInvocationBodyContext, 0)
-}
-
-FunctionInvocationContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-FunctionInvocationContext.prototype.DISTINCT = function() {
-  return this.getToken(CypherParser.DISTINCT, 0)
-}
-
-FunctionInvocationContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-FunctionInvocationContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterFunctionInvocation(this)
-  }
-}
-
-FunctionInvocationContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitFunctionInvocation(this)
-  }
-}
-
-CypherParser.FunctionInvocationContext = FunctionInvocationContext
-
-CypherParser.prototype.functionInvocation = function() {
-  var localctx = new FunctionInvocationContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 338, CypherParser.RULE_functionInvocation)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2351
-    this.functionInvocationBody()
-    this.state = 2353
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2352
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2355
-    this.match(CypherParser.T__18)
-    this.state = 2357
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2356
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2363
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 354, this._ctx)
-    if (la_ === 1) {
-      this.state = 2359
-      this.match(CypherParser.DISTINCT)
-      this.state = 2361
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2360
-        this.match(CypherParser.SP)
-      }
-    }
-    this.state = 2382
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      ((_la & ~0x1f) == 0 &&
-        ((1 << _la) &
-          ((1 << CypherParser.T__2) |
-            (1 << CypherParser.T__12) |
-            (1 << CypherParser.T__13) |
-            (1 << CypherParser.T__16) |
-            (1 << CypherParser.T__18))) !==
-          0) ||
-      (((_la - 34) & ~0x1f) == 0 &&
-        ((1 << (_la - 34)) &
-          ((1 << (CypherParser.T__33 - 34)) |
-            (1 << (CypherParser.CYPHER - 34)) |
-            (1 << (CypherParser.EXPLAIN - 34)) |
-            (1 << (CypherParser.PROFILE - 34)) |
-            (1 << (CypherParser.USING - 34)) |
-            (1 << (CypherParser.PERIODIC - 34)) |
-            (1 << (CypherParser.COMMIT - 34)) |
-            (1 << (CypherParser.UNION - 34)) |
-            (1 << (CypherParser.ALL - 34)) |
-            (1 << (CypherParser.CREATE - 34)) |
-            (1 << (CypherParser.DROP - 34)) |
-            (1 << (CypherParser.INDEX - 34)) |
-            (1 << (CypherParser.ON - 34)))) !==
-          0) ||
-      (((_la - 66) & ~0x1f) == 0 &&
-        ((1 << (_la - 66)) &
-          ((1 << (CypherParser.CONSTRAINT - 66)) |
-            (1 << (CypherParser.ASSERT - 66)) |
-            (1 << (CypherParser.IS - 66)) |
-            (1 << (CypherParser.UNIQUE - 66)) |
-            (1 << (CypherParser.EXISTS - 66)) |
-            (1 << (CypherParser.LOAD - 66)) |
-            (1 << (CypherParser.CSV - 66)) |
-            (1 << (CypherParser.WITH - 66)) |
-            (1 << (CypherParser.HEADERS - 66)) |
-            (1 << (CypherParser.FROM - 66)) |
-            (1 << (CypherParser.AS - 66)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 66)) |
-            (1 << (CypherParser.OPTIONAL - 66)) |
-            (1 << (CypherParser.MATCH - 66)) |
-            (1 << (CypherParser.UNWIND - 66)) |
-            (1 << (CypherParser.MERGE - 66)) |
-            (1 << (CypherParser.SET - 66)) |
-            (1 << (CypherParser.DETACH - 66)) |
-            (1 << (CypherParser.DELETE - 66)) |
-            (1 << (CypherParser.REMOVE - 66)) |
-            (1 << (CypherParser.FOREACH - 66)) |
-            (1 << (CypherParser.IN - 66)) |
-            (1 << (CypherParser.DISTINCT - 66)) |
-            (1 << (CypherParser.RETURN - 66)) |
-            (1 << (CypherParser.ORDER - 66)) |
-            (1 << (CypherParser.BY - 66)) |
-            (1 << (CypherParser.L_SKIP - 66)) |
-            (1 << (CypherParser.LIMIT - 66)) |
-            (1 << (CypherParser.ASCENDING - 66)) |
-            (1 << (CypherParser.ASC - 66)) |
-            (1 << (CypherParser.DESCENDING - 66)) |
-            (1 << (CypherParser.DESC - 66)))) !==
-          0) ||
-      (((_la - 98) & ~0x1f) == 0 &&
-        ((1 << (_la - 98)) &
-          ((1 << (CypherParser.JOIN - 98)) |
-            (1 << (CypherParser.SCAN - 98)) |
-            (1 << (CypherParser.START - 98)) |
-            (1 << (CypherParser.NODE - 98)) |
-            (1 << (CypherParser.RELATIONSHIP - 98)) |
-            (1 << (CypherParser.REL - 98)) |
-            (1 << (CypherParser.WHERE - 98)) |
-            (1 << (CypherParser.SHORTESTPATH - 98)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 98)) |
-            (1 << (CypherParser.OR - 98)) |
-            (1 << (CypherParser.XOR - 98)) |
-            (1 << (CypherParser.AND - 98)) |
-            (1 << (CypherParser.NOT - 98)) |
-            (1 << (CypherParser.STARTS - 98)) |
-            (1 << (CypherParser.ENDS - 98)) |
-            (1 << (CypherParser.CONTAINS - 98)) |
-            (1 << (CypherParser.NULL - 98)) |
-            (1 << (CypherParser.COUNT - 98)) |
-            (1 << (CypherParser.FILTER - 98)) |
-            (1 << (CypherParser.EXTRACT - 98)) |
-            (1 << (CypherParser.ANY - 98)) |
-            (1 << (CypherParser.NONE - 98)) |
-            (1 << (CypherParser.SINGLE - 98)) |
-            (1 << (CypherParser.TRUE - 98)) |
-            (1 << (CypherParser.FALSE - 98)) |
-            (1 << (CypherParser.REDUCE - 98)) |
-            (1 << (CypherParser.CASE - 98)) |
-            (1 << (CypherParser.ELSE - 98)) |
-            (1 << (CypherParser.END - 98)) |
-            (1 << (CypherParser.WHEN - 98)) |
-            (1 << (CypherParser.THEN - 98)) |
-            (1 << (CypherParser.CALL - 98)))) !==
-          0) ||
-      (((_la - 130) & ~0x1f) == 0 &&
-        ((1 << (_la - 130)) &
-          ((1 << (CypherParser.YIELD - 130)) |
-            (1 << (CypherParser.KEY - 130)) |
-            (1 << (CypherParser.StringLiteral - 130)) |
-            (1 << (CypherParser.HexInteger - 130)) |
-            (1 << (CypherParser.DecimalInteger - 130)) |
-            (1 << (CypherParser.OctalInteger - 130)) |
-            (1 << (CypherParser.HexLetter - 130)) |
-            (1 << (CypherParser.ExponentDecimalReal - 130)) |
-            (1 << (CypherParser.RegularDecimalReal - 130)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 130)) |
-            (1 << (CypherParser.EscapedSymbolicName - 130)))) !==
-          0)
-    ) {
-      this.state = 2365
-      this.expression()
-      this.state = 2367
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2366
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2379
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      while (_la === CypherParser.T__14) {
-        this.state = 2369
-        this.match(CypherParser.T__14)
-        this.state = 2371
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2370
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2373
-        this.expression()
-        this.state = 2375
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2374
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2381
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-      }
-    }
-
-    this.state = 2384
-    this.match(CypherParser.T__19)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function FunctionInvocationBodyContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_functionInvocationBody
-  return this
-}
-
-FunctionInvocationBodyContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-FunctionInvocationBodyContext.prototype.constructor = FunctionInvocationBodyContext
-
-FunctionInvocationBodyContext.prototype.namespace = function() {
-  return this.getTypedRuleContext(NamespaceContext, 0)
-}
-
-FunctionInvocationBodyContext.prototype.functionName = function() {
-  return this.getTypedRuleContext(FunctionNameContext, 0)
-}
-
-FunctionInvocationBodyContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterFunctionInvocationBody(this)
-  }
-}
-
-FunctionInvocationBodyContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitFunctionInvocationBody(this)
-  }
-}
-
-CypherParser.FunctionInvocationBodyContext = FunctionInvocationBodyContext
-
-CypherParser.prototype.functionInvocationBody = function() {
-  var localctx = new FunctionInvocationBodyContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 340, CypherParser.RULE_functionInvocationBody)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2386
-    this.namespace()
-    this.state = 2387
-    this.functionName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function FunctionNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_functionName
-  return this
-}
-
-FunctionNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-FunctionNameContext.prototype.constructor = FunctionNameContext
-
-FunctionNameContext.prototype.UnescapedSymbolicName = function() {
-  return this.getToken(CypherParser.UnescapedSymbolicName, 0)
-}
-
-FunctionNameContext.prototype.EscapedSymbolicName = function() {
-  return this.getToken(CypherParser.EscapedSymbolicName, 0)
-}
-
-FunctionNameContext.prototype.COUNT = function() {
-  return this.getToken(CypherParser.COUNT, 0)
-}
-
-FunctionNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterFunctionName(this)
-  }
-}
-
-FunctionNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitFunctionName(this)
-  }
-}
-
-CypherParser.FunctionNameContext = FunctionNameContext
-
-CypherParser.prototype.functionName = function() {
-  var localctx = new FunctionNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 342, CypherParser.RULE_functionName)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2389
-    _la = this._input.LA(1)
-    if (
-      !(
-        _la === CypherParser.COUNT ||
-        _la === CypherParser.UnescapedSymbolicName ||
-        _la === CypherParser.EscapedSymbolicName
-      )
-    ) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ProcedureNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_procedureName
-  return this
-}
-
-ProcedureNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ProcedureNameContext.prototype.constructor = ProcedureNameContext
-
-ProcedureNameContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-ProcedureNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterProcedureName(this)
-  }
-}
-
-ProcedureNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitProcedureName(this)
-  }
-}
-
-CypherParser.ProcedureNameContext = ProcedureNameContext
-
-CypherParser.prototype.procedureName = function() {
-  var localctx = new ProcedureNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 344, CypherParser.RULE_procedureName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2391
-    this.symbolicName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ListComprehensionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_listComprehension
-  return this
-}
-
-ListComprehensionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ListComprehensionContext.prototype.constructor = ListComprehensionContext
-
-ListComprehensionContext.prototype.filterExpression = function() {
-  return this.getTypedRuleContext(FilterExpressionContext, 0)
-}
-
-ListComprehensionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-ListComprehensionContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-ListComprehensionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterListComprehension(this)
-  }
-}
-
-ListComprehensionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitListComprehension(this)
-  }
-}
-
-CypherParser.ListComprehensionContext = ListComprehensionContext
-
-CypherParser.prototype.listComprehension = function() {
-  var localctx = new ListComprehensionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 346, CypherParser.RULE_listComprehension)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2393
-    this.match(CypherParser.T__16)
-    this.state = 2395
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2394
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2397
-    this.filterExpression()
-    this.state = 2406
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 363, this._ctx)
-    if (la_ === 1) {
-      this.state = 2399
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2398
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2401
-      this.match(CypherParser.T__21)
-      this.state = 2403
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2402
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2405
-      this.expression()
-    }
-    this.state = 2409
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2408
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2411
-    this.match(CypherParser.T__17)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PatternComprehensionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_patternComprehension
-  return this
-}
-
-PatternComprehensionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PatternComprehensionContext.prototype.constructor = PatternComprehensionContext
-
-PatternComprehensionContext.prototype.relationshipsPattern = function() {
-  return this.getTypedRuleContext(RelationshipsPatternContext, 0)
-}
-
-PatternComprehensionContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-PatternComprehensionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PatternComprehensionContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-PatternComprehensionContext.prototype.WHERE = function() {
-  return this.getToken(CypherParser.WHERE, 0)
-}
-
-PatternComprehensionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPatternComprehension(this)
-  }
-}
-
-PatternComprehensionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPatternComprehension(this)
-  }
-}
-
-CypherParser.PatternComprehensionContext = PatternComprehensionContext
-
-CypherParser.prototype.patternComprehension = function() {
-  var localctx = new PatternComprehensionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 348, CypherParser.RULE_patternComprehension)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2413
-    this.match(CypherParser.T__16)
-    this.state = 2415
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2414
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2425
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      (((_la - 54) & ~0x1f) == 0 &&
-        ((1 << (_la - 54)) &
-          ((1 << (CypherParser.CYPHER - 54)) |
-            (1 << (CypherParser.EXPLAIN - 54)) |
-            (1 << (CypherParser.PROFILE - 54)) |
-            (1 << (CypherParser.USING - 54)) |
-            (1 << (CypherParser.PERIODIC - 54)) |
-            (1 << (CypherParser.COMMIT - 54)) |
-            (1 << (CypherParser.UNION - 54)) |
-            (1 << (CypherParser.ALL - 54)) |
-            (1 << (CypherParser.CREATE - 54)) |
-            (1 << (CypherParser.DROP - 54)) |
-            (1 << (CypherParser.INDEX - 54)) |
-            (1 << (CypherParser.ON - 54)) |
-            (1 << (CypherParser.CONSTRAINT - 54)) |
-            (1 << (CypherParser.ASSERT - 54)) |
-            (1 << (CypherParser.IS - 54)) |
-            (1 << (CypherParser.UNIQUE - 54)) |
-            (1 << (CypherParser.EXISTS - 54)) |
-            (1 << (CypherParser.LOAD - 54)) |
-            (1 << (CypherParser.CSV - 54)) |
-            (1 << (CypherParser.WITH - 54)) |
-            (1 << (CypherParser.HEADERS - 54)) |
-            (1 << (CypherParser.FROM - 54)) |
-            (1 << (CypherParser.AS - 54)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
-            (1 << (CypherParser.OPTIONAL - 54)) |
-            (1 << (CypherParser.MATCH - 54)) |
-            (1 << (CypherParser.UNWIND - 54)) |
-            (1 << (CypherParser.MERGE - 54)) |
-            (1 << (CypherParser.SET - 54)) |
-            (1 << (CypherParser.DETACH - 54)) |
-            (1 << (CypherParser.DELETE - 54)) |
-            (1 << (CypherParser.REMOVE - 54)))) !==
-          0) ||
-      (((_la - 86) & ~0x1f) == 0 &&
-        ((1 << (_la - 86)) &
-          ((1 << (CypherParser.FOREACH - 86)) |
-            (1 << (CypherParser.IN - 86)) |
-            (1 << (CypherParser.DISTINCT - 86)) |
-            (1 << (CypherParser.RETURN - 86)) |
-            (1 << (CypherParser.ORDER - 86)) |
-            (1 << (CypherParser.BY - 86)) |
-            (1 << (CypherParser.L_SKIP - 86)) |
-            (1 << (CypherParser.LIMIT - 86)) |
-            (1 << (CypherParser.ASCENDING - 86)) |
-            (1 << (CypherParser.ASC - 86)) |
-            (1 << (CypherParser.DESCENDING - 86)) |
-            (1 << (CypherParser.DESC - 86)) |
-            (1 << (CypherParser.JOIN - 86)) |
-            (1 << (CypherParser.SCAN - 86)) |
-            (1 << (CypherParser.START - 86)) |
-            (1 << (CypherParser.NODE - 86)) |
-            (1 << (CypherParser.RELATIONSHIP - 86)) |
-            (1 << (CypherParser.REL - 86)) |
-            (1 << (CypherParser.WHERE - 86)) |
-            (1 << (CypherParser.SHORTESTPATH - 86)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
-            (1 << (CypherParser.OR - 86)) |
-            (1 << (CypherParser.XOR - 86)) |
-            (1 << (CypherParser.AND - 86)) |
-            (1 << (CypherParser.NOT - 86)) |
-            (1 << (CypherParser.STARTS - 86)) |
-            (1 << (CypherParser.ENDS - 86)) |
-            (1 << (CypherParser.CONTAINS - 86)) |
-            (1 << (CypherParser.NULL - 86)) |
-            (1 << (CypherParser.COUNT - 86)) |
-            (1 << (CypherParser.FILTER - 86)) |
-            (1 << (CypherParser.EXTRACT - 86)))) !==
-          0) ||
-      (((_la - 118) & ~0x1f) == 0 &&
-        ((1 << (_la - 118)) &
-          ((1 << (CypherParser.ANY - 118)) |
-            (1 << (CypherParser.NONE - 118)) |
-            (1 << (CypherParser.SINGLE - 118)) |
-            (1 << (CypherParser.TRUE - 118)) |
-            (1 << (CypherParser.FALSE - 118)) |
-            (1 << (CypherParser.REDUCE - 118)) |
-            (1 << (CypherParser.CASE - 118)) |
-            (1 << (CypherParser.ELSE - 118)) |
-            (1 << (CypherParser.END - 118)) |
-            (1 << (CypherParser.WHEN - 118)) |
-            (1 << (CypherParser.THEN - 118)) |
-            (1 << (CypherParser.CALL - 118)) |
-            (1 << (CypherParser.YIELD - 118)) |
-            (1 << (CypherParser.KEY - 118)) |
-            (1 << (CypherParser.HexLetter - 118)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
-          0) ||
-      _la === CypherParser.EscapedSymbolicName
-    ) {
-      this.state = 2417
-      this.variable()
-      this.state = 2419
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2418
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2421
-      this.match(CypherParser.T__11)
-      this.state = 2423
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2422
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 2427
-    this.relationshipsPattern()
-    this.state = 2429
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2428
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2439
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.WHERE) {
-      this.state = 2431
-      this.match(CypherParser.WHERE)
-      this.state = 2433
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2432
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2435
-      this.expression()
-      this.state = 2437
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2436
-        this.match(CypherParser.SP)
-      }
-    }
-
-    this.state = 2441
-    this.match(CypherParser.T__21)
-    this.state = 2443
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2442
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2445
-    this.expression()
-    this.state = 2447
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2446
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2449
-    this.match(CypherParser.T__17)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertyLookupContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_propertyLookup
-  return this
-}
-
-PropertyLookupContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PropertyLookupContext.prototype.constructor = PropertyLookupContext
-
-PropertyLookupContext.prototype.propertyKeyName = function() {
-  return this.getTypedRuleContext(PropertyKeyNameContext, 0)
-}
-
-PropertyLookupContext.prototype.SP = function() {
-  return this.getToken(CypherParser.SP, 0)
-}
-
-PropertyLookupContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPropertyLookup(this)
-  }
-}
-
-PropertyLookupContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPropertyLookup(this)
-  }
-}
-
-CypherParser.PropertyLookupContext = PropertyLookupContext
-
-CypherParser.prototype.propertyLookup = function() {
-  var localctx = new PropertyLookupContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 350, CypherParser.RULE_propertyLookup)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2451
-    this.match(CypherParser.T__6)
-    this.state = 2453
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2452
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2455
-    this.propertyKeyName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CaseExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_caseExpression
-  return this
-}
-
-CaseExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CaseExpressionContext.prototype.constructor = CaseExpressionContext
-
-CaseExpressionContext.prototype.END = function() {
-  return this.getToken(CypherParser.END, 0)
-}
-
-CaseExpressionContext.prototype.ELSE = function() {
-  return this.getToken(CypherParser.ELSE, 0)
-}
-
-CaseExpressionContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-CaseExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-CaseExpressionContext.prototype.CASE = function() {
-  return this.getToken(CypherParser.CASE, 0)
-}
-
-CaseExpressionContext.prototype.caseAlternatives = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(CaseAlternativesContext)
-  } else {
-    return this.getTypedRuleContext(CaseAlternativesContext, i)
-  }
-}
-
-CaseExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCaseExpression(this)
-  }
-}
-
-CaseExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCaseExpression(this)
-  }
-}
-
-CypherParser.CaseExpressionContext = CaseExpressionContext
-
-CypherParser.prototype.caseExpression = function() {
-  var localctx = new CaseExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 352, CypherParser.RULE_caseExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2479
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 381, this._ctx)
-    switch (la_) {
-      case 1:
-        this.state = 2457
-        this.match(CypherParser.CASE)
-        this.state = 2462
-        this._errHandler.sync(this)
-        var _alt = 1
-        do {
-          switch (_alt) {
-            case 1:
-              this.state = 2459
-              this._errHandler.sync(this)
-              _la = this._input.LA(1)
-              if (_la === CypherParser.SP) {
-                this.state = 2458
-                this.match(CypherParser.SP)
-              }
-
-              this.state = 2461
-              this.caseAlternatives()
-              break
-            default:
-              throw new antlr4.error.NoViableAltException(this)
-          }
-          this.state = 2464
-          this._errHandler.sync(this)
-          _alt = this._interp.adaptivePredict(this._input, 377, this._ctx)
-        } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
-        break
-
-      case 2:
-        this.state = 2466
-        this.match(CypherParser.CASE)
-        this.state = 2468
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2467
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2470
-        this.expression()
-        this.state = 2475
-        this._errHandler.sync(this)
-        var _alt = 1
-        do {
-          switch (_alt) {
-            case 1:
-              this.state = 2472
-              this._errHandler.sync(this)
-              _la = this._input.LA(1)
-              if (_la === CypherParser.SP) {
-                this.state = 2471
-                this.match(CypherParser.SP)
-              }
-
-              this.state = 2474
-              this.caseAlternatives()
-              break
-            default:
-              throw new antlr4.error.NoViableAltException(this)
-          }
-          this.state = 2477
-          this._errHandler.sync(this)
-          _alt = this._interp.adaptivePredict(this._input, 380, this._ctx)
-        } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
-        break
-    }
-    this.state = 2489
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 384, this._ctx)
-    if (la_ === 1) {
-      this.state = 2482
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2481
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2484
-      this.match(CypherParser.ELSE)
-      this.state = 2486
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2485
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2488
-      this.expression()
-    }
-    this.state = 2492
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2491
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2494
-    this.match(CypherParser.END)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function CaseAlternativesContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_caseAlternatives
-  return this
-}
-
-CaseAlternativesContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-CaseAlternativesContext.prototype.constructor = CaseAlternativesContext
-
-CaseAlternativesContext.prototype.WHEN = function() {
-  return this.getToken(CypherParser.WHEN, 0)
-}
-
-CaseAlternativesContext.prototype.expression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(ExpressionContext)
-  } else {
-    return this.getTypedRuleContext(ExpressionContext, i)
-  }
-}
-
-CaseAlternativesContext.prototype.THEN = function() {
-  return this.getToken(CypherParser.THEN, 0)
-}
-
-CaseAlternativesContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-CaseAlternativesContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterCaseAlternatives(this)
-  }
-}
-
-CaseAlternativesContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitCaseAlternatives(this)
-  }
-}
-
-CypherParser.CaseAlternativesContext = CaseAlternativesContext
-
-CypherParser.prototype.caseAlternatives = function() {
-  var localctx = new CaseAlternativesContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 354, CypherParser.RULE_caseAlternatives)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2496
-    this.match(CypherParser.WHEN)
-    this.state = 2498
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2497
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2500
-    this.expression()
-    this.state = 2502
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2501
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2504
-    this.match(CypherParser.THEN)
-    this.state = 2506
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2505
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2508
-    this.expression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function VariableContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_variable
-  return this
-}
-
-VariableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-VariableContext.prototype.constructor = VariableContext
-
-VariableContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-VariableContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterVariable(this)
-  }
-}
-
-VariableContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitVariable(this)
-  }
-}
-
-CypherParser.VariableContext = VariableContext
-
-CypherParser.prototype.variable = function() {
-  var localctx = new VariableContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 356, CypherParser.RULE_variable)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2510
-    this.symbolicName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NumberLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_numberLiteral
-  return this
-}
-
-NumberLiteralContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-NumberLiteralContext.prototype.constructor = NumberLiteralContext
-
-NumberLiteralContext.prototype.doubleLiteral = function() {
-  return this.getTypedRuleContext(DoubleLiteralContext, 0)
-}
-
-NumberLiteralContext.prototype.integerLiteral = function() {
-  return this.getTypedRuleContext(IntegerLiteralContext, 0)
-}
-
-NumberLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNumberLiteral(this)
-  }
-}
-
-NumberLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNumberLiteral(this)
-  }
-}
-
-CypherParser.NumberLiteralContext = NumberLiteralContext
-
-CypherParser.prototype.numberLiteral = function() {
-  var localctx = new NumberLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 358, CypherParser.RULE_numberLiteral)
-  try {
-    this.state = 2514
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.ExponentDecimalReal:
-      case CypherParser.RegularDecimalReal:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2512
-        this.doubleLiteral()
-        break
-      case CypherParser.HexInteger:
-      case CypherParser.DecimalInteger:
-      case CypherParser.OctalInteger:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2513
-        this.integerLiteral()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function MapLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_mapLiteral
-  return this
-}
-
-MapLiteralContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-MapLiteralContext.prototype.constructor = MapLiteralContext
-
-MapLiteralContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-MapLiteralContext.prototype.literalEntry = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(LiteralEntryContext)
-  } else {
-    return this.getTypedRuleContext(LiteralEntryContext, i)
-  }
-}
-
-MapLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterMapLiteral(this)
-  }
-}
-
-MapLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitMapLiteral(this)
-  }
-}
-
-CypherParser.MapLiteralContext = MapLiteralContext
-
-CypherParser.prototype.mapLiteral = function() {
-  var localctx = new MapLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 360, CypherParser.RULE_mapLiteral)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2516
-    this.match(CypherParser.T__13)
-    this.state = 2518
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2517
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2537
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      (((_la - 54) & ~0x1f) == 0 &&
-        ((1 << (_la - 54)) &
-          ((1 << (CypherParser.CYPHER - 54)) |
-            (1 << (CypherParser.EXPLAIN - 54)) |
-            (1 << (CypherParser.PROFILE - 54)) |
-            (1 << (CypherParser.USING - 54)) |
-            (1 << (CypherParser.PERIODIC - 54)) |
-            (1 << (CypherParser.COMMIT - 54)) |
-            (1 << (CypherParser.UNION - 54)) |
-            (1 << (CypherParser.ALL - 54)) |
-            (1 << (CypherParser.CREATE - 54)) |
-            (1 << (CypherParser.DROP - 54)) |
-            (1 << (CypherParser.INDEX - 54)) |
-            (1 << (CypherParser.ON - 54)) |
-            (1 << (CypherParser.CONSTRAINT - 54)) |
-            (1 << (CypherParser.ASSERT - 54)) |
-            (1 << (CypherParser.IS - 54)) |
-            (1 << (CypherParser.UNIQUE - 54)) |
-            (1 << (CypherParser.EXISTS - 54)) |
-            (1 << (CypherParser.LOAD - 54)) |
-            (1 << (CypherParser.CSV - 54)) |
-            (1 << (CypherParser.WITH - 54)) |
-            (1 << (CypherParser.HEADERS - 54)) |
-            (1 << (CypherParser.FROM - 54)) |
-            (1 << (CypherParser.AS - 54)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
-            (1 << (CypherParser.OPTIONAL - 54)) |
-            (1 << (CypherParser.MATCH - 54)) |
-            (1 << (CypherParser.UNWIND - 54)) |
-            (1 << (CypherParser.MERGE - 54)) |
-            (1 << (CypherParser.SET - 54)) |
-            (1 << (CypherParser.DETACH - 54)) |
-            (1 << (CypherParser.DELETE - 54)) |
-            (1 << (CypherParser.REMOVE - 54)))) !==
-          0) ||
-      (((_la - 86) & ~0x1f) == 0 &&
-        ((1 << (_la - 86)) &
-          ((1 << (CypherParser.FOREACH - 86)) |
-            (1 << (CypherParser.IN - 86)) |
-            (1 << (CypherParser.DISTINCT - 86)) |
-            (1 << (CypherParser.RETURN - 86)) |
-            (1 << (CypherParser.ORDER - 86)) |
-            (1 << (CypherParser.BY - 86)) |
-            (1 << (CypherParser.L_SKIP - 86)) |
-            (1 << (CypherParser.LIMIT - 86)) |
-            (1 << (CypherParser.ASCENDING - 86)) |
-            (1 << (CypherParser.ASC - 86)) |
-            (1 << (CypherParser.DESCENDING - 86)) |
-            (1 << (CypherParser.DESC - 86)) |
-            (1 << (CypherParser.JOIN - 86)) |
-            (1 << (CypherParser.SCAN - 86)) |
-            (1 << (CypherParser.START - 86)) |
-            (1 << (CypherParser.NODE - 86)) |
-            (1 << (CypherParser.RELATIONSHIP - 86)) |
-            (1 << (CypherParser.REL - 86)) |
-            (1 << (CypherParser.WHERE - 86)) |
-            (1 << (CypherParser.SHORTESTPATH - 86)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
-            (1 << (CypherParser.OR - 86)) |
-            (1 << (CypherParser.XOR - 86)) |
-            (1 << (CypherParser.AND - 86)) |
-            (1 << (CypherParser.NOT - 86)) |
-            (1 << (CypherParser.STARTS - 86)) |
-            (1 << (CypherParser.ENDS - 86)) |
-            (1 << (CypherParser.CONTAINS - 86)) |
-            (1 << (CypherParser.NULL - 86)) |
-            (1 << (CypherParser.COUNT - 86)) |
-            (1 << (CypherParser.FILTER - 86)) |
-            (1 << (CypherParser.EXTRACT - 86)))) !==
-          0) ||
-      (((_la - 118) & ~0x1f) == 0 &&
-        ((1 << (_la - 118)) &
-          ((1 << (CypherParser.ANY - 118)) |
-            (1 << (CypherParser.NONE - 118)) |
-            (1 << (CypherParser.SINGLE - 118)) |
-            (1 << (CypherParser.TRUE - 118)) |
-            (1 << (CypherParser.FALSE - 118)) |
-            (1 << (CypherParser.REDUCE - 118)) |
-            (1 << (CypherParser.CASE - 118)) |
-            (1 << (CypherParser.ELSE - 118)) |
-            (1 << (CypherParser.END - 118)) |
-            (1 << (CypherParser.WHEN - 118)) |
-            (1 << (CypherParser.THEN - 118)) |
-            (1 << (CypherParser.CALL - 118)) |
-            (1 << (CypherParser.YIELD - 118)) |
-            (1 << (CypherParser.KEY - 118)) |
-            (1 << (CypherParser.HexLetter - 118)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
-          0) ||
-      _la === CypherParser.EscapedSymbolicName
-    ) {
-      this.state = 2520
-      this.literalEntry()
-      this.state = 2522
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      if (_la === CypherParser.SP) {
-        this.state = 2521
-        this.match(CypherParser.SP)
-      }
-
-      this.state = 2534
-      this._errHandler.sync(this)
-      _la = this._input.LA(1)
-      while (_la === CypherParser.T__14) {
-        this.state = 2524
-        this.match(CypherParser.T__14)
-        this.state = 2526
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2525
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2528
-        this.literalEntry()
-        this.state = 2530
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2529
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2536
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-      }
-    }
-
-    this.state = 2539
-    this.match(CypherParser.T__15)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function MapProjectionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_mapProjection
-  return this
-}
-
-MapProjectionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-MapProjectionContext.prototype.constructor = MapProjectionContext
-
-MapProjectionContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-MapProjectionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-MapProjectionContext.prototype.mapProjectionVariants = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(MapProjectionVariantsContext)
-  } else {
-    return this.getTypedRuleContext(MapProjectionVariantsContext, i)
-  }
-}
-
-MapProjectionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterMapProjection(this)
-  }
-}
-
-MapProjectionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitMapProjection(this)
-  }
-}
-
-CypherParser.MapProjectionContext = MapProjectionContext
-
-CypherParser.prototype.mapProjection = function() {
-  var localctx = new MapProjectionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 362, CypherParser.RULE_mapProjection)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2541
-    this.variable()
-    this.state = 2543
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2542
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2545
-    this.match(CypherParser.T__13)
-    this.state = 2547
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 397, this._ctx)
-    if (la_ === 1) {
-      this.state = 2546
-      this.match(CypherParser.SP)
-    }
-    this.state = 2550
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (
-      _la === CypherParser.T__6 ||
-      (((_la - 54) & ~0x1f) == 0 &&
-        ((1 << (_la - 54)) &
-          ((1 << (CypherParser.CYPHER - 54)) |
-            (1 << (CypherParser.EXPLAIN - 54)) |
-            (1 << (CypherParser.PROFILE - 54)) |
-            (1 << (CypherParser.USING - 54)) |
-            (1 << (CypherParser.PERIODIC - 54)) |
-            (1 << (CypherParser.COMMIT - 54)) |
-            (1 << (CypherParser.UNION - 54)) |
-            (1 << (CypherParser.ALL - 54)) |
-            (1 << (CypherParser.CREATE - 54)) |
-            (1 << (CypherParser.DROP - 54)) |
-            (1 << (CypherParser.INDEX - 54)) |
-            (1 << (CypherParser.ON - 54)) |
-            (1 << (CypherParser.CONSTRAINT - 54)) |
-            (1 << (CypherParser.ASSERT - 54)) |
-            (1 << (CypherParser.IS - 54)) |
-            (1 << (CypherParser.UNIQUE - 54)) |
-            (1 << (CypherParser.EXISTS - 54)) |
-            (1 << (CypherParser.LOAD - 54)) |
-            (1 << (CypherParser.CSV - 54)) |
-            (1 << (CypherParser.WITH - 54)) |
-            (1 << (CypherParser.HEADERS - 54)) |
-            (1 << (CypherParser.FROM - 54)) |
-            (1 << (CypherParser.AS - 54)) |
-            (1 << (CypherParser.FIELDTERMINATOR - 54)) |
-            (1 << (CypherParser.OPTIONAL - 54)) |
-            (1 << (CypherParser.MATCH - 54)) |
-            (1 << (CypherParser.UNWIND - 54)) |
-            (1 << (CypherParser.MERGE - 54)) |
-            (1 << (CypherParser.SET - 54)) |
-            (1 << (CypherParser.DETACH - 54)) |
-            (1 << (CypherParser.DELETE - 54)) |
-            (1 << (CypherParser.REMOVE - 54)))) !==
-          0) ||
-      (((_la - 86) & ~0x1f) == 0 &&
-        ((1 << (_la - 86)) &
-          ((1 << (CypherParser.FOREACH - 86)) |
-            (1 << (CypherParser.IN - 86)) |
-            (1 << (CypherParser.DISTINCT - 86)) |
-            (1 << (CypherParser.RETURN - 86)) |
-            (1 << (CypherParser.ORDER - 86)) |
-            (1 << (CypherParser.BY - 86)) |
-            (1 << (CypherParser.L_SKIP - 86)) |
-            (1 << (CypherParser.LIMIT - 86)) |
-            (1 << (CypherParser.ASCENDING - 86)) |
-            (1 << (CypherParser.ASC - 86)) |
-            (1 << (CypherParser.DESCENDING - 86)) |
-            (1 << (CypherParser.DESC - 86)) |
-            (1 << (CypherParser.JOIN - 86)) |
-            (1 << (CypherParser.SCAN - 86)) |
-            (1 << (CypherParser.START - 86)) |
-            (1 << (CypherParser.NODE - 86)) |
-            (1 << (CypherParser.RELATIONSHIP - 86)) |
-            (1 << (CypherParser.REL - 86)) |
-            (1 << (CypherParser.WHERE - 86)) |
-            (1 << (CypherParser.SHORTESTPATH - 86)) |
-            (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
-            (1 << (CypherParser.OR - 86)) |
-            (1 << (CypherParser.XOR - 86)) |
-            (1 << (CypherParser.AND - 86)) |
-            (1 << (CypherParser.NOT - 86)) |
-            (1 << (CypherParser.STARTS - 86)) |
-            (1 << (CypherParser.ENDS - 86)) |
-            (1 << (CypherParser.CONTAINS - 86)) |
-            (1 << (CypherParser.NULL - 86)) |
-            (1 << (CypherParser.COUNT - 86)) |
-            (1 << (CypherParser.FILTER - 86)) |
-            (1 << (CypherParser.EXTRACT - 86)))) !==
-          0) ||
-      (((_la - 118) & ~0x1f) == 0 &&
-        ((1 << (_la - 118)) &
-          ((1 << (CypherParser.ANY - 118)) |
-            (1 << (CypherParser.NONE - 118)) |
-            (1 << (CypherParser.SINGLE - 118)) |
-            (1 << (CypherParser.TRUE - 118)) |
-            (1 << (CypherParser.FALSE - 118)) |
-            (1 << (CypherParser.REDUCE - 118)) |
-            (1 << (CypherParser.CASE - 118)) |
-            (1 << (CypherParser.ELSE - 118)) |
-            (1 << (CypherParser.END - 118)) |
-            (1 << (CypherParser.WHEN - 118)) |
-            (1 << (CypherParser.THEN - 118)) |
-            (1 << (CypherParser.CALL - 118)) |
-            (1 << (CypherParser.YIELD - 118)) |
-            (1 << (CypherParser.KEY - 118)) |
-            (1 << (CypherParser.HexLetter - 118)) |
-            (1 << (CypherParser.UnescapedSymbolicName - 118)))) !==
-          0) ||
-      _la === CypherParser.EscapedSymbolicName
-    ) {
-      this.state = 2549
-      this.mapProjectionVariants()
-    }
-
-    this.state = 2562
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 401, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 2553
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2552
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2555
-        this.match(CypherParser.T__14)
-        this.state = 2557
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2556
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2559
-        this.mapProjectionVariants()
-      }
-      this.state = 2564
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 401, this._ctx)
-    }
-
-    this.state = 2566
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2565
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2568
-    this.match(CypherParser.T__15)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function MapProjectionVariantsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_mapProjectionVariants
-  return this
-}
-
-MapProjectionVariantsContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-MapProjectionVariantsContext.prototype.constructor = MapProjectionVariantsContext
-
-MapProjectionVariantsContext.prototype.literalEntry = function() {
-  return this.getTypedRuleContext(LiteralEntryContext, 0)
-}
-
-MapProjectionVariantsContext.prototype.propertySelector = function() {
-  return this.getTypedRuleContext(PropertySelectorContext, 0)
-}
-
-MapProjectionVariantsContext.prototype.variableSelector = function() {
-  return this.getTypedRuleContext(VariableSelectorContext, 0)
-}
-
-MapProjectionVariantsContext.prototype.allPropertiesSelector = function() {
-  return this.getTypedRuleContext(AllPropertiesSelectorContext, 0)
-}
-
-MapProjectionVariantsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterMapProjectionVariants(this)
-  }
-}
-
-MapProjectionVariantsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitMapProjectionVariants(this)
-  }
-}
-
-CypherParser.MapProjectionVariantsContext = MapProjectionVariantsContext
-
-CypherParser.prototype.mapProjectionVariants = function() {
-  var localctx = new MapProjectionVariantsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 364, CypherParser.RULE_mapProjectionVariants)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2574
-    this._errHandler.sync(this)
-    var la_ = this._interp.adaptivePredict(this._input, 403, this._ctx)
-    switch (la_) {
-      case 1:
-        this.state = 2570
-        this.literalEntry()
-        break
-
-      case 2:
-        this.state = 2571
-        this.propertySelector()
-        break
-
-      case 3:
-        this.state = 2572
-        this.variableSelector()
-        break
-
-      case 4:
-        this.state = 2573
-        this.allPropertiesSelector()
-        break
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LiteralEntryContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_literalEntry
-  return this
-}
-
-LiteralEntryContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-LiteralEntryContext.prototype.constructor = LiteralEntryContext
-
-LiteralEntryContext.prototype.propertyKeyName = function() {
-  return this.getTypedRuleContext(PropertyKeyNameContext, 0)
-}
-
-LiteralEntryContext.prototype.expression = function() {
-  return this.getTypedRuleContext(ExpressionContext, 0)
-}
-
-LiteralEntryContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-LiteralEntryContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLiteralEntry(this)
-  }
-}
-
-LiteralEntryContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLiteralEntry(this)
-  }
-}
-
-CypherParser.LiteralEntryContext = LiteralEntryContext
-
-CypherParser.prototype.literalEntry = function() {
-  var localctx = new LiteralEntryContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 366, CypherParser.RULE_literalEntry)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2576
-    this.propertyKeyName()
-    this.state = 2578
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2577
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2580
-    this.match(CypherParser.T__1)
-    this.state = 2582
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2581
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2584
-    this.expression()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertySelectorContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_propertySelector
-  return this
-}
-
-PropertySelectorContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PropertySelectorContext.prototype.constructor = PropertySelectorContext
-
-PropertySelectorContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-PropertySelectorContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPropertySelector(this)
-  }
-}
-
-PropertySelectorContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPropertySelector(this)
-  }
-}
-
-CypherParser.PropertySelectorContext = PropertySelectorContext
-
-CypherParser.prototype.propertySelector = function() {
-  var localctx = new PropertySelectorContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 368, CypherParser.RULE_propertySelector)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2586
-    this.match(CypherParser.T__6)
-    this.state = 2587
-    this.variable()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function VariableSelectorContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_variableSelector
-  return this
-}
-
-VariableSelectorContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-VariableSelectorContext.prototype.constructor = VariableSelectorContext
-
-VariableSelectorContext.prototype.variable = function() {
-  return this.getTypedRuleContext(VariableContext, 0)
-}
-
-VariableSelectorContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterVariableSelector(this)
-  }
-}
-
-VariableSelectorContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitVariableSelector(this)
-  }
-}
-
-CypherParser.VariableSelectorContext = VariableSelectorContext
-
-CypherParser.prototype.variableSelector = function() {
-  var localctx = new VariableSelectorContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 370, CypherParser.RULE_variableSelector)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2589
-    this.variable()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function AllPropertiesSelectorContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_allPropertiesSelector
-  return this
-}
-
-AllPropertiesSelectorContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-AllPropertiesSelectorContext.prototype.constructor = AllPropertiesSelectorContext
-
-AllPropertiesSelectorContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterAllPropertiesSelector(this)
-  }
-}
-
-AllPropertiesSelectorContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitAllPropertiesSelector(this)
-  }
-}
-
-CypherParser.AllPropertiesSelectorContext = AllPropertiesSelectorContext
-
-CypherParser.prototype.allPropertiesSelector = function() {
-  var localctx = new AllPropertiesSelectorContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 372, CypherParser.RULE_allPropertiesSelector)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2591
-    this.match(CypherParser.T__6)
-    this.state = 2592
-    this.match(CypherParser.T__22)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ParameterContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_parameter
-  return this
-}
-
-ParameterContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-ParameterContext.prototype.constructor = ParameterContext
-
-ParameterContext.prototype.legacyParameter = function() {
-  return this.getTypedRuleContext(LegacyParameterContext, 0)
-}
-
-ParameterContext.prototype.newParameter = function() {
-  return this.getTypedRuleContext(NewParameterContext, 0)
-}
-
-ParameterContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterParameter(this)
-  }
-}
-
-ParameterContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitParameter(this)
-  }
-}
-
-CypherParser.ParameterContext = ParameterContext
-
-CypherParser.prototype.parameter = function() {
-  var localctx = new ParameterContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 374, CypherParser.RULE_parameter)
-  try {
-    this.state = 2596
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.T__13:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2594
-        this.legacyParameter()
-        break
-      case CypherParser.T__33:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2595
-        this.newParameter()
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LegacyParameterContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_legacyParameter
-  return this
-}
-
-LegacyParameterContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-LegacyParameterContext.prototype.constructor = LegacyParameterContext
-
-LegacyParameterContext.prototype.parameterName = function() {
-  return this.getTypedRuleContext(ParameterNameContext, 0)
-}
-
-LegacyParameterContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-LegacyParameterContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLegacyParameter(this)
-  }
-}
-
-LegacyParameterContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLegacyParameter(this)
-  }
-}
-
-CypherParser.LegacyParameterContext = LegacyParameterContext
-
-CypherParser.prototype.legacyParameter = function() {
-  var localctx = new LegacyParameterContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 376, CypherParser.RULE_legacyParameter)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2598
-    this.match(CypherParser.T__13)
-    this.state = 2600
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2599
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2602
-    this.parameterName()
-    this.state = 2604
-    this._errHandler.sync(this)
-    _la = this._input.LA(1)
-    if (_la === CypherParser.SP) {
-      this.state = 2603
-      this.match(CypherParser.SP)
-    }
-
-    this.state = 2606
-    this.match(CypherParser.T__15)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NewParameterContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_newParameter
-  return this
-}
-
-NewParameterContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-NewParameterContext.prototype.constructor = NewParameterContext
-
-NewParameterContext.prototype.parameterName = function() {
-  return this.getTypedRuleContext(ParameterNameContext, 0)
-}
-
-NewParameterContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNewParameter(this)
-  }
-}
-
-NewParameterContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNewParameter(this)
-  }
-}
-
-CypherParser.NewParameterContext = NewParameterContext
-
-CypherParser.prototype.newParameter = function() {
-  var localctx = new NewParameterContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 378, CypherParser.RULE_newParameter)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2608
-    this.match(CypherParser.T__33)
-    this.state = 2609
-    this.parameterName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function ParameterNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_parameterName
-  return this
-}
-
-ParameterNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-ParameterNameContext.prototype.constructor = ParameterNameContext
-
-ParameterNameContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-ParameterNameContext.prototype.DecimalInteger = function() {
-  return this.getToken(CypherParser.DecimalInteger, 0)
-}
-
-ParameterNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterParameterName(this)
-  }
-}
-
-ParameterNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitParameterName(this)
-  }
-}
-
-CypherParser.ParameterNameContext = ParameterNameContext
-
-CypherParser.prototype.parameterName = function() {
-  var localctx = new ParameterNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 380, CypherParser.RULE_parameterName)
-  try {
-    this.state = 2613
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.CYPHER:
-      case CypherParser.EXPLAIN:
-      case CypherParser.PROFILE:
-      case CypherParser.USING:
-      case CypherParser.PERIODIC:
-      case CypherParser.COMMIT:
-      case CypherParser.UNION:
-      case CypherParser.ALL:
-      case CypherParser.CREATE:
-      case CypherParser.DROP:
-      case CypherParser.INDEX:
-      case CypherParser.ON:
-      case CypherParser.CONSTRAINT:
-      case CypherParser.ASSERT:
-      case CypherParser.IS:
-      case CypherParser.UNIQUE:
-      case CypherParser.EXISTS:
-      case CypherParser.LOAD:
-      case CypherParser.CSV:
-      case CypherParser.WITH:
-      case CypherParser.HEADERS:
-      case CypherParser.FROM:
-      case CypherParser.AS:
-      case CypherParser.FIELDTERMINATOR:
-      case CypherParser.OPTIONAL:
-      case CypherParser.MATCH:
-      case CypherParser.UNWIND:
-      case CypherParser.MERGE:
-      case CypherParser.SET:
-      case CypherParser.DETACH:
-      case CypherParser.DELETE:
-      case CypherParser.REMOVE:
-      case CypherParser.FOREACH:
-      case CypherParser.IN:
-      case CypherParser.DISTINCT:
-      case CypherParser.RETURN:
-      case CypherParser.ORDER:
-      case CypherParser.BY:
-      case CypherParser.L_SKIP:
-      case CypherParser.LIMIT:
-      case CypherParser.ASCENDING:
-      case CypherParser.ASC:
-      case CypherParser.DESCENDING:
-      case CypherParser.DESC:
-      case CypherParser.JOIN:
-      case CypherParser.SCAN:
-      case CypherParser.START:
-      case CypherParser.NODE:
-      case CypherParser.RELATIONSHIP:
-      case CypherParser.REL:
-      case CypherParser.WHERE:
-      case CypherParser.SHORTESTPATH:
-      case CypherParser.ALLSHORTESTPATHS:
-      case CypherParser.OR:
-      case CypherParser.XOR:
-      case CypherParser.AND:
-      case CypherParser.NOT:
-      case CypherParser.STARTS:
-      case CypherParser.ENDS:
-      case CypherParser.CONTAINS:
-      case CypherParser.NULL:
-      case CypherParser.COUNT:
-      case CypherParser.FILTER:
-      case CypherParser.EXTRACT:
-      case CypherParser.ANY:
-      case CypherParser.NONE:
-      case CypherParser.SINGLE:
-      case CypherParser.TRUE:
-      case CypherParser.FALSE:
-      case CypherParser.REDUCE:
-      case CypherParser.CASE:
-      case CypherParser.ELSE:
-      case CypherParser.END:
-      case CypherParser.WHEN:
-      case CypherParser.THEN:
-      case CypherParser.CALL:
-      case CypherParser.YIELD:
-      case CypherParser.KEY:
-      case CypherParser.HexLetter:
-      case CypherParser.UnescapedSymbolicName:
-      case CypherParser.EscapedSymbolicName:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2611
-        this.symbolicName()
-        break
-      case CypherParser.DecimalInteger:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2612
-        this.match(CypherParser.DecimalInteger)
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertyExpressionsContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_propertyExpressions
-  return this
-}
-
-PropertyExpressionsContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PropertyExpressionsContext.prototype.constructor = PropertyExpressionsContext
-
-PropertyExpressionsContext.prototype.propertyExpression = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PropertyExpressionContext)
-  } else {
-    return this.getTypedRuleContext(PropertyExpressionContext, i)
-  }
-}
-
-PropertyExpressionsContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PropertyExpressionsContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPropertyExpressions(this)
-  }
-}
-
-PropertyExpressionsContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPropertyExpressions(this)
-  }
-}
-
-CypherParser.PropertyExpressionsContext = PropertyExpressionsContext
-
-CypherParser.prototype.propertyExpressions = function() {
-  var localctx = new PropertyExpressionsContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 382, CypherParser.RULE_propertyExpressions)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2615
-    this.propertyExpression()
-    this.state = 2626
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 412, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 2617
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2616
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2619
-        this.match(CypherParser.T__14)
-        this.state = 2621
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2620
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2623
-        this.propertyExpression()
-      }
-      this.state = 2628
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 412, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertyExpressionContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_propertyExpression
-  return this
-}
-
-PropertyExpressionContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PropertyExpressionContext.prototype.constructor = PropertyExpressionContext
-
-PropertyExpressionContext.prototype.atom = function() {
-  return this.getTypedRuleContext(AtomContext, 0)
-}
-
-PropertyExpressionContext.prototype.propertyLookup = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PropertyLookupContext)
-  } else {
-    return this.getTypedRuleContext(PropertyLookupContext, i)
-  }
-}
-
-PropertyExpressionContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PropertyExpressionContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPropertyExpression(this)
-  }
-}
-
-PropertyExpressionContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPropertyExpression(this)
-  }
-}
-
-CypherParser.PropertyExpressionContext = PropertyExpressionContext
-
-CypherParser.prototype.propertyExpression = function() {
-  var localctx = new PropertyExpressionContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 384, CypherParser.RULE_propertyExpression)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2629
-    this.atom()
-    this.state = 2634
-    this._errHandler.sync(this)
-    var _alt = 1
-    do {
-      switch (_alt) {
-        case 1:
-          this.state = 2631
-          this._errHandler.sync(this)
-          _la = this._input.LA(1)
-          if (_la === CypherParser.SP) {
-            this.state = 2630
-            this.match(CypherParser.SP)
-          }
-
-          this.state = 2633
-          this.propertyLookup()
-          break
-        default:
-          throw new antlr4.error.NoViableAltException(this)
-      }
-      this.state = 2636
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 414, this._ctx)
-    } while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER)
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertyKeysContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_propertyKeys
-  return this
-}
-
-PropertyKeysContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PropertyKeysContext.prototype.constructor = PropertyKeysContext
-
-PropertyKeysContext.prototype.propertyKeyName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(PropertyKeyNameContext)
-  } else {
-    return this.getTypedRuleContext(PropertyKeyNameContext, i)
-  }
-}
-
-PropertyKeysContext.prototype.SP = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTokens(CypherParser.SP)
-  } else {
-    return this.getToken(CypherParser.SP, i)
-  }
-}
-
-PropertyKeysContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPropertyKeys(this)
-  }
-}
-
-PropertyKeysContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPropertyKeys(this)
-  }
-}
-
-CypherParser.PropertyKeysContext = PropertyKeysContext
-
-CypherParser.prototype.propertyKeys = function() {
-  var localctx = new PropertyKeysContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 386, CypherParser.RULE_propertyKeys)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2638
-    this.propertyKeyName()
-    this.state = 2649
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 417, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 2640
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2639
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2642
-        this.match(CypherParser.T__14)
-        this.state = 2644
-        this._errHandler.sync(this)
-        _la = this._input.LA(1)
-        if (_la === CypherParser.SP) {
-          this.state = 2643
-          this.match(CypherParser.SP)
-        }
-
-        this.state = 2646
-        this.propertyKeyName()
-      }
-      this.state = 2651
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 417, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function PropertyKeyNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_propertyKeyName
-  return this
-}
-
-PropertyKeyNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-PropertyKeyNameContext.prototype.constructor = PropertyKeyNameContext
-
-PropertyKeyNameContext.prototype.symbolicName = function() {
-  return this.getTypedRuleContext(SymbolicNameContext, 0)
-}
-
-PropertyKeyNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterPropertyKeyName(this)
-  }
-}
-
-PropertyKeyNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitPropertyKeyName(this)
-  }
-}
-
-CypherParser.PropertyKeyNameContext = PropertyKeyNameContext
-
-CypherParser.prototype.propertyKeyName = function() {
-  var localctx = new PropertyKeyNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 388, CypherParser.RULE_propertyKeyName)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2652
-    this.symbolicName()
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function IntegerLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_integerLiteral
-  return this
-}
-
-IntegerLiteralContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-IntegerLiteralContext.prototype.constructor = IntegerLiteralContext
-
-IntegerLiteralContext.prototype.HexInteger = function() {
-  return this.getToken(CypherParser.HexInteger, 0)
-}
-
-IntegerLiteralContext.prototype.OctalInteger = function() {
-  return this.getToken(CypherParser.OctalInteger, 0)
-}
-
-IntegerLiteralContext.prototype.DecimalInteger = function() {
-  return this.getToken(CypherParser.DecimalInteger, 0)
-}
-
-IntegerLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterIntegerLiteral(this)
-  }
-}
-
-IntegerLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitIntegerLiteral(this)
-  }
-}
-
-CypherParser.IntegerLiteralContext = IntegerLiteralContext
-
-CypherParser.prototype.integerLiteral = function() {
-  var localctx = new IntegerLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 390, CypherParser.RULE_integerLiteral)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2654
-    _la = this._input.LA(1)
-    if (
-      !(
-        ((_la - 135) & ~0x1f) == 0 &&
-        ((1 << (_la - 135)) &
-          ((1 << (CypherParser.HexInteger - 135)) |
-            (1 << (CypherParser.DecimalInteger - 135)) |
-            (1 << (CypherParser.OctalInteger - 135)))) !==
-          0
-      )
-    ) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DoubleLiteralContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_doubleLiteral
-  return this
-}
-
-DoubleLiteralContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-DoubleLiteralContext.prototype.constructor = DoubleLiteralContext
-
-DoubleLiteralContext.prototype.ExponentDecimalReal = function() {
-  return this.getToken(CypherParser.ExponentDecimalReal, 0)
-}
-
-DoubleLiteralContext.prototype.RegularDecimalReal = function() {
-  return this.getToken(CypherParser.RegularDecimalReal, 0)
-}
-
-DoubleLiteralContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterDoubleLiteral(this)
-  }
-}
-
-DoubleLiteralContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitDoubleLiteral(this)
-  }
-}
-
-CypherParser.DoubleLiteralContext = DoubleLiteralContext
-
-CypherParser.prototype.doubleLiteral = function() {
-  var localctx = new DoubleLiteralContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 392, CypherParser.RULE_doubleLiteral)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2656
-    _la = this._input.LA(1)
-    if (
-      !(
-        _la === CypherParser.ExponentDecimalReal ||
-        _la === CypherParser.RegularDecimalReal
-      )
-    ) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function NamespaceContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_namespace
-  return this
-}
-
-NamespaceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-NamespaceContext.prototype.constructor = NamespaceContext
-
-NamespaceContext.prototype.symbolicName = function(i) {
-  if (i === undefined) {
-    i = null
-  }
-  if (i === null) {
-    return this.getTypedRuleContexts(SymbolicNameContext)
-  } else {
-    return this.getTypedRuleContext(SymbolicNameContext, i)
-  }
-}
-
-NamespaceContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterNamespace(this)
-  }
-}
-
-NamespaceContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitNamespace(this)
-  }
-}
-
-CypherParser.NamespaceContext = NamespaceContext
-
-CypherParser.prototype.namespace = function() {
-  var localctx = new NamespaceContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 394, CypherParser.RULE_namespace)
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2663
-    this._errHandler.sync(this)
-    var _alt = this._interp.adaptivePredict(this._input, 418, this._ctx)
-    while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
-      if (_alt === 1) {
-        this.state = 2658
-        this.symbolicName()
-        this.state = 2659
-        this.match(CypherParser.T__6)
-      }
-      this.state = 2665
-      this._errHandler.sync(this)
-      _alt = this._interp.adaptivePredict(this._input, 418, this._ctx)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function LeftArrowHeadContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_leftArrowHead
-  return this
-}
-
-LeftArrowHeadContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-LeftArrowHeadContext.prototype.constructor = LeftArrowHeadContext
-
-LeftArrowHeadContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterLeftArrowHead(this)
-  }
-}
-
-LeftArrowHeadContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitLeftArrowHead(this)
-  }
-}
-
-CypherParser.LeftArrowHeadContext = LeftArrowHeadContext
-
-CypherParser.prototype.leftArrowHead = function() {
-  var localctx = new LeftArrowHeadContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 396, CypherParser.RULE_leftArrowHead)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2666
-    _la = this._input.LA(1)
-    if (
-      !(
-        ((_la - 30) & ~0x1f) == 0 &&
-        ((1 << (_la - 30)) &
-          ((1 << (CypherParser.T__29 - 30)) |
-            (1 << (CypherParser.T__34 - 30)) |
-            (1 << (CypherParser.T__35 - 30)) |
-            (1 << (CypherParser.T__36 - 30)) |
-            (1 << (CypherParser.T__37 - 30)))) !==
-          0
-      )
-    ) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function RightArrowHeadContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_rightArrowHead
-  return this
-}
-
-RightArrowHeadContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-RightArrowHeadContext.prototype.constructor = RightArrowHeadContext
-
-RightArrowHeadContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterRightArrowHead(this)
-  }
-}
-
-RightArrowHeadContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitRightArrowHead(this)
-  }
-}
-
-CypherParser.RightArrowHeadContext = RightArrowHeadContext
-
-CypherParser.prototype.rightArrowHead = function() {
-  var localctx = new RightArrowHeadContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 398, CypherParser.RULE_rightArrowHead)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2668
-    _la = this._input.LA(1)
-    if (
-      !(
-        ((_la - 31) & ~0x1f) == 0 &&
-        ((1 << (_la - 31)) &
-          ((1 << (CypherParser.T__30 - 31)) |
-            (1 << (CypherParser.T__38 - 31)) |
-            (1 << (CypherParser.T__39 - 31)) |
-            (1 << (CypherParser.T__40 - 31)) |
-            (1 << (CypherParser.T__41 - 31)))) !==
-          0
-      )
-    ) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function DashContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_dash
-  return this
-}
-
-DashContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-DashContext.prototype.constructor = DashContext
-
-DashContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterDash(this)
-  }
-}
-
-DashContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitDash(this)
-  }
-}
-
-CypherParser.DashContext = DashContext
-
-CypherParser.prototype.dash = function() {
-  var localctx = new DashContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 400, CypherParser.RULE_dash)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2670
-    _la = this._input.LA(1)
-    if (
-      !(
-        _la === CypherParser.T__2 ||
-        (((_la - 43) & ~0x1f) == 0 &&
-          ((1 << (_la - 43)) &
-            ((1 << (CypherParser.T__42 - 43)) |
-              (1 << (CypherParser.T__43 - 43)) |
-              (1 << (CypherParser.T__44 - 43)) |
-              (1 << (CypherParser.T__45 - 43)) |
-              (1 << (CypherParser.T__46 - 43)) |
-              (1 << (CypherParser.T__47 - 43)) |
-              (1 << (CypherParser.T__48 - 43)) |
-              (1 << (CypherParser.T__49 - 43)) |
-              (1 << (CypherParser.T__50 - 43)) |
-              (1 << (CypherParser.T__51 - 43)) |
-              (1 << (CypherParser.T__52 - 43)))) !==
-            0)
-      )
-    ) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function SymbolicNameContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_symbolicName
-  return this
-}
-
-SymbolicNameContext.prototype = Object.create(
-  antlr4.ParserRuleContext.prototype
-)
-SymbolicNameContext.prototype.constructor = SymbolicNameContext
-
-SymbolicNameContext.prototype.keyword = function() {
-  return this.getTypedRuleContext(KeywordContext, 0)
-}
-
-SymbolicNameContext.prototype.UnescapedSymbolicName = function() {
-  return this.getToken(CypherParser.UnescapedSymbolicName, 0)
-}
-
-SymbolicNameContext.prototype.EscapedSymbolicName = function() {
-  return this.getToken(CypherParser.EscapedSymbolicName, 0)
-}
-
-SymbolicNameContext.prototype.HexLetter = function() {
-  return this.getToken(CypherParser.HexLetter, 0)
-}
-
-SymbolicNameContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterSymbolicName(this)
-  }
-}
-
-SymbolicNameContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitSymbolicName(this)
-  }
-}
-
-CypherParser.SymbolicNameContext = SymbolicNameContext
-
-CypherParser.prototype.symbolicName = function() {
-  var localctx = new SymbolicNameContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 402, CypherParser.RULE_symbolicName)
-  try {
-    this.state = 2676
-    this._errHandler.sync(this)
-    switch (this._input.LA(1)) {
-      case CypherParser.CYPHER:
-      case CypherParser.EXPLAIN:
-      case CypherParser.PROFILE:
-      case CypherParser.USING:
-      case CypherParser.PERIODIC:
-      case CypherParser.COMMIT:
-      case CypherParser.UNION:
-      case CypherParser.ALL:
-      case CypherParser.CREATE:
-      case CypherParser.DROP:
-      case CypherParser.INDEX:
-      case CypherParser.ON:
-      case CypherParser.CONSTRAINT:
-      case CypherParser.ASSERT:
-      case CypherParser.IS:
-      case CypherParser.UNIQUE:
-      case CypherParser.EXISTS:
-      case CypherParser.LOAD:
-      case CypherParser.CSV:
-      case CypherParser.WITH:
-      case CypherParser.HEADERS:
-      case CypherParser.FROM:
-      case CypherParser.AS:
-      case CypherParser.FIELDTERMINATOR:
-      case CypherParser.OPTIONAL:
-      case CypherParser.MATCH:
-      case CypherParser.UNWIND:
-      case CypherParser.MERGE:
-      case CypherParser.SET:
-      case CypherParser.DETACH:
-      case CypherParser.DELETE:
-      case CypherParser.REMOVE:
-      case CypherParser.FOREACH:
-      case CypherParser.IN:
-      case CypherParser.DISTINCT:
-      case CypherParser.RETURN:
-      case CypherParser.ORDER:
-      case CypherParser.BY:
-      case CypherParser.L_SKIP:
-      case CypherParser.LIMIT:
-      case CypherParser.ASCENDING:
-      case CypherParser.ASC:
-      case CypherParser.DESCENDING:
-      case CypherParser.DESC:
-      case CypherParser.JOIN:
-      case CypherParser.SCAN:
-      case CypherParser.START:
-      case CypherParser.NODE:
-      case CypherParser.RELATIONSHIP:
-      case CypherParser.REL:
-      case CypherParser.WHERE:
-      case CypherParser.SHORTESTPATH:
-      case CypherParser.ALLSHORTESTPATHS:
-      case CypherParser.OR:
-      case CypherParser.XOR:
-      case CypherParser.AND:
-      case CypherParser.NOT:
-      case CypherParser.STARTS:
-      case CypherParser.ENDS:
-      case CypherParser.CONTAINS:
-      case CypherParser.NULL:
-      case CypherParser.COUNT:
-      case CypherParser.FILTER:
-      case CypherParser.EXTRACT:
-      case CypherParser.ANY:
-      case CypherParser.NONE:
-      case CypherParser.SINGLE:
-      case CypherParser.TRUE:
-      case CypherParser.FALSE:
-      case CypherParser.REDUCE:
-      case CypherParser.CASE:
-      case CypherParser.ELSE:
-      case CypherParser.END:
-      case CypherParser.WHEN:
-      case CypherParser.THEN:
-      case CypherParser.CALL:
-      case CypherParser.YIELD:
-      case CypherParser.KEY:
-        this.enterOuterAlt(localctx, 1)
-        this.state = 2672
-        this.keyword()
-        break
-      case CypherParser.UnescapedSymbolicName:
-        this.enterOuterAlt(localctx, 2)
-        this.state = 2673
-        this.match(CypherParser.UnescapedSymbolicName)
-        break
-      case CypherParser.EscapedSymbolicName:
-        this.enterOuterAlt(localctx, 3)
-        this.state = 2674
-        this.match(CypherParser.EscapedSymbolicName)
-        break
-      case CypherParser.HexLetter:
-        this.enterOuterAlt(localctx, 4)
-        this.state = 2675
-        this.match(CypherParser.HexLetter)
-        break
-      default:
-        throw new antlr4.error.NoViableAltException(this)
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-function KeywordContext(parser, parent, invokingState) {
-  if (parent === undefined) {
-    parent = null
-  }
-  if (invokingState === undefined || invokingState === null) {
-    invokingState = -1
-  }
-  antlr4.ParserRuleContext.call(this, parent, invokingState)
-  this.parser = parser
-  this.ruleIndex = CypherParser.RULE_keyword
-  return this
-}
-
-KeywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype)
-KeywordContext.prototype.constructor = KeywordContext
-
-KeywordContext.prototype.CYPHER = function() {
-  return this.getToken(CypherParser.CYPHER, 0)
-}
-
-KeywordContext.prototype.EXPLAIN = function() {
-  return this.getToken(CypherParser.EXPLAIN, 0)
-}
-
-KeywordContext.prototype.PROFILE = function() {
-  return this.getToken(CypherParser.PROFILE, 0)
-}
-
-KeywordContext.prototype.USING = function() {
-  return this.getToken(CypherParser.USING, 0)
-}
-
-KeywordContext.prototype.PERIODIC = function() {
-  return this.getToken(CypherParser.PERIODIC, 0)
-}
-
-KeywordContext.prototype.COMMIT = function() {
-  return this.getToken(CypherParser.COMMIT, 0)
-}
-
-KeywordContext.prototype.UNION = function() {
-  return this.getToken(CypherParser.UNION, 0)
-}
-
-KeywordContext.prototype.ALL = function() {
-  return this.getToken(CypherParser.ALL, 0)
-}
-
-KeywordContext.prototype.CREATE = function() {
-  return this.getToken(CypherParser.CREATE, 0)
-}
-
-KeywordContext.prototype.DROP = function() {
-  return this.getToken(CypherParser.DROP, 0)
-}
-
-KeywordContext.prototype.INDEX = function() {
-  return this.getToken(CypherParser.INDEX, 0)
-}
-
-KeywordContext.prototype.ON = function() {
-  return this.getToken(CypherParser.ON, 0)
-}
-
-KeywordContext.prototype.CONSTRAINT = function() {
-  return this.getToken(CypherParser.CONSTRAINT, 0)
-}
-
-KeywordContext.prototype.ASSERT = function() {
-  return this.getToken(CypherParser.ASSERT, 0)
-}
-
-KeywordContext.prototype.IS = function() {
-  return this.getToken(CypherParser.IS, 0)
-}
-
-KeywordContext.prototype.UNIQUE = function() {
-  return this.getToken(CypherParser.UNIQUE, 0)
-}
-
-KeywordContext.prototype.EXISTS = function() {
-  return this.getToken(CypherParser.EXISTS, 0)
-}
-
-KeywordContext.prototype.LOAD = function() {
-  return this.getToken(CypherParser.LOAD, 0)
-}
-
-KeywordContext.prototype.CSV = function() {
-  return this.getToken(CypherParser.CSV, 0)
-}
-
-KeywordContext.prototype.WITH = function() {
-  return this.getToken(CypherParser.WITH, 0)
-}
-
-KeywordContext.prototype.HEADERS = function() {
-  return this.getToken(CypherParser.HEADERS, 0)
-}
-
-KeywordContext.prototype.FROM = function() {
-  return this.getToken(CypherParser.FROM, 0)
-}
-
-KeywordContext.prototype.AS = function() {
-  return this.getToken(CypherParser.AS, 0)
-}
-
-KeywordContext.prototype.FIELDTERMINATOR = function() {
-  return this.getToken(CypherParser.FIELDTERMINATOR, 0)
-}
-
-KeywordContext.prototype.OPTIONAL = function() {
-  return this.getToken(CypherParser.OPTIONAL, 0)
-}
-
-KeywordContext.prototype.MATCH = function() {
-  return this.getToken(CypherParser.MATCH, 0)
-}
-
-KeywordContext.prototype.UNWIND = function() {
-  return this.getToken(CypherParser.UNWIND, 0)
-}
-
-KeywordContext.prototype.MERGE = function() {
-  return this.getToken(CypherParser.MERGE, 0)
-}
-
-KeywordContext.prototype.SET = function() {
-  return this.getToken(CypherParser.SET, 0)
-}
-
-KeywordContext.prototype.DETACH = function() {
-  return this.getToken(CypherParser.DETACH, 0)
-}
-
-KeywordContext.prototype.DELETE = function() {
-  return this.getToken(CypherParser.DELETE, 0)
-}
-
-KeywordContext.prototype.REMOVE = function() {
-  return this.getToken(CypherParser.REMOVE, 0)
-}
-
-KeywordContext.prototype.FOREACH = function() {
-  return this.getToken(CypherParser.FOREACH, 0)
-}
-
-KeywordContext.prototype.IN = function() {
-  return this.getToken(CypherParser.IN, 0)
-}
-
-KeywordContext.prototype.DISTINCT = function() {
-  return this.getToken(CypherParser.DISTINCT, 0)
-}
-
-KeywordContext.prototype.RETURN = function() {
-  return this.getToken(CypherParser.RETURN, 0)
-}
-
-KeywordContext.prototype.ORDER = function() {
-  return this.getToken(CypherParser.ORDER, 0)
-}
-
-KeywordContext.prototype.BY = function() {
-  return this.getToken(CypherParser.BY, 0)
-}
-
-KeywordContext.prototype.L_SKIP = function() {
-  return this.getToken(CypherParser.L_SKIP, 0)
-}
-
-KeywordContext.prototype.LIMIT = function() {
-  return this.getToken(CypherParser.LIMIT, 0)
-}
-
-KeywordContext.prototype.ASCENDING = function() {
-  return this.getToken(CypherParser.ASCENDING, 0)
-}
-
-KeywordContext.prototype.ASC = function() {
-  return this.getToken(CypherParser.ASC, 0)
-}
-
-KeywordContext.prototype.DESCENDING = function() {
-  return this.getToken(CypherParser.DESCENDING, 0)
-}
-
-KeywordContext.prototype.DESC = function() {
-  return this.getToken(CypherParser.DESC, 0)
-}
-
-KeywordContext.prototype.JOIN = function() {
-  return this.getToken(CypherParser.JOIN, 0)
-}
-
-KeywordContext.prototype.SCAN = function() {
-  return this.getToken(CypherParser.SCAN, 0)
-}
-
-KeywordContext.prototype.START = function() {
-  return this.getToken(CypherParser.START, 0)
-}
-
-KeywordContext.prototype.NODE = function() {
-  return this.getToken(CypherParser.NODE, 0)
-}
-
-KeywordContext.prototype.RELATIONSHIP = function() {
-  return this.getToken(CypherParser.RELATIONSHIP, 0)
-}
-
-KeywordContext.prototype.REL = function() {
-  return this.getToken(CypherParser.REL, 0)
-}
-
-KeywordContext.prototype.WHERE = function() {
-  return this.getToken(CypherParser.WHERE, 0)
-}
-
-KeywordContext.prototype.SHORTESTPATH = function() {
-  return this.getToken(CypherParser.SHORTESTPATH, 0)
-}
-
-KeywordContext.prototype.ALLSHORTESTPATHS = function() {
-  return this.getToken(CypherParser.ALLSHORTESTPATHS, 0)
-}
-
-KeywordContext.prototype.OR = function() {
-  return this.getToken(CypherParser.OR, 0)
-}
-
-KeywordContext.prototype.XOR = function() {
-  return this.getToken(CypherParser.XOR, 0)
-}
-
-KeywordContext.prototype.AND = function() {
-  return this.getToken(CypherParser.AND, 0)
-}
-
-KeywordContext.prototype.NOT = function() {
-  return this.getToken(CypherParser.NOT, 0)
-}
-
-KeywordContext.prototype.STARTS = function() {
-  return this.getToken(CypherParser.STARTS, 0)
-}
-
-KeywordContext.prototype.ENDS = function() {
-  return this.getToken(CypherParser.ENDS, 0)
-}
-
-KeywordContext.prototype.CONTAINS = function() {
-  return this.getToken(CypherParser.CONTAINS, 0)
-}
-
-KeywordContext.prototype.NULL = function() {
-  return this.getToken(CypherParser.NULL, 0)
-}
-
-KeywordContext.prototype.COUNT = function() {
-  return this.getToken(CypherParser.COUNT, 0)
-}
-
-KeywordContext.prototype.FILTER = function() {
-  return this.getToken(CypherParser.FILTER, 0)
-}
-
-KeywordContext.prototype.EXTRACT = function() {
-  return this.getToken(CypherParser.EXTRACT, 0)
-}
-
-KeywordContext.prototype.ANY = function() {
-  return this.getToken(CypherParser.ANY, 0)
-}
-
-KeywordContext.prototype.NONE = function() {
-  return this.getToken(CypherParser.NONE, 0)
-}
-
-KeywordContext.prototype.SINGLE = function() {
-  return this.getToken(CypherParser.SINGLE, 0)
-}
-
-KeywordContext.prototype.TRUE = function() {
-  return this.getToken(CypherParser.TRUE, 0)
-}
-
-KeywordContext.prototype.FALSE = function() {
-  return this.getToken(CypherParser.FALSE, 0)
-}
-
-KeywordContext.prototype.REDUCE = function() {
-  return this.getToken(CypherParser.REDUCE, 0)
-}
-
-KeywordContext.prototype.CASE = function() {
-  return this.getToken(CypherParser.CASE, 0)
-}
-
-KeywordContext.prototype.ELSE = function() {
-  return this.getToken(CypherParser.ELSE, 0)
-}
-
-KeywordContext.prototype.END = function() {
-  return this.getToken(CypherParser.END, 0)
-}
-
-KeywordContext.prototype.WHEN = function() {
-  return this.getToken(CypherParser.WHEN, 0)
-}
-
-KeywordContext.prototype.THEN = function() {
-  return this.getToken(CypherParser.THEN, 0)
-}
-
-KeywordContext.prototype.CALL = function() {
-  return this.getToken(CypherParser.CALL, 0)
-}
-
-KeywordContext.prototype.YIELD = function() {
-  return this.getToken(CypherParser.YIELD, 0)
-}
-
-KeywordContext.prototype.KEY = function() {
-  return this.getToken(CypherParser.KEY, 0)
-}
-
-KeywordContext.prototype.enterRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.enterKeyword(this)
-  }
-}
-
-KeywordContext.prototype.exitRule = function(listener) {
-  if (listener instanceof CypherListener) {
-    listener.exitKeyword(this)
-  }
-}
-
-CypherParser.KeywordContext = KeywordContext
-
-CypherParser.prototype.keyword = function() {
-  var localctx = new KeywordContext(this, this._ctx, this.state)
-  this.enterRule(localctx, 404, CypherParser.RULE_keyword)
-  var _la = 0 // Token type
-  try {
-    this.enterOuterAlt(localctx, 1)
-    this.state = 2678
-    _la = this._input.LA(1)
-    if (
-      !(
-        (((_la - 54) & ~0x1f) == 0 &&
-          ((1 << (_la - 54)) &
-            ((1 << (CypherParser.CYPHER - 54)) |
-              (1 << (CypherParser.EXPLAIN - 54)) |
-              (1 << (CypherParser.PROFILE - 54)) |
-              (1 << (CypherParser.USING - 54)) |
-              (1 << (CypherParser.PERIODIC - 54)) |
-              (1 << (CypherParser.COMMIT - 54)) |
-              (1 << (CypherParser.UNION - 54)) |
-              (1 << (CypherParser.ALL - 54)) |
-              (1 << (CypherParser.CREATE - 54)) |
-              (1 << (CypherParser.DROP - 54)) |
-              (1 << (CypherParser.INDEX - 54)) |
-              (1 << (CypherParser.ON - 54)) |
-              (1 << (CypherParser.CONSTRAINT - 54)) |
-              (1 << (CypherParser.ASSERT - 54)) |
-              (1 << (CypherParser.IS - 54)) |
-              (1 << (CypherParser.UNIQUE - 54)) |
-              (1 << (CypherParser.EXISTS - 54)) |
-              (1 << (CypherParser.LOAD - 54)) |
-              (1 << (CypherParser.CSV - 54)) |
-              (1 << (CypherParser.WITH - 54)) |
-              (1 << (CypherParser.HEADERS - 54)) |
-              (1 << (CypherParser.FROM - 54)) |
-              (1 << (CypherParser.AS - 54)) |
-              (1 << (CypherParser.FIELDTERMINATOR - 54)) |
-              (1 << (CypherParser.OPTIONAL - 54)) |
-              (1 << (CypherParser.MATCH - 54)) |
-              (1 << (CypherParser.UNWIND - 54)) |
-              (1 << (CypherParser.MERGE - 54)) |
-              (1 << (CypherParser.SET - 54)) |
-              (1 << (CypherParser.DETACH - 54)) |
-              (1 << (CypherParser.DELETE - 54)) |
-              (1 << (CypherParser.REMOVE - 54)))) !==
-            0) ||
-        (((_la - 86) & ~0x1f) == 0 &&
-          ((1 << (_la - 86)) &
-            ((1 << (CypherParser.FOREACH - 86)) |
-              (1 << (CypherParser.IN - 86)) |
-              (1 << (CypherParser.DISTINCT - 86)) |
-              (1 << (CypherParser.RETURN - 86)) |
-              (1 << (CypherParser.ORDER - 86)) |
-              (1 << (CypherParser.BY - 86)) |
-              (1 << (CypherParser.L_SKIP - 86)) |
-              (1 << (CypherParser.LIMIT - 86)) |
-              (1 << (CypherParser.ASCENDING - 86)) |
-              (1 << (CypherParser.ASC - 86)) |
-              (1 << (CypherParser.DESCENDING - 86)) |
-              (1 << (CypherParser.DESC - 86)) |
-              (1 << (CypherParser.JOIN - 86)) |
-              (1 << (CypherParser.SCAN - 86)) |
-              (1 << (CypherParser.START - 86)) |
-              (1 << (CypherParser.NODE - 86)) |
-              (1 << (CypherParser.RELATIONSHIP - 86)) |
-              (1 << (CypherParser.REL - 86)) |
-              (1 << (CypherParser.WHERE - 86)) |
-              (1 << (CypherParser.SHORTESTPATH - 86)) |
-              (1 << (CypherParser.ALLSHORTESTPATHS - 86)) |
-              (1 << (CypherParser.OR - 86)) |
-              (1 << (CypherParser.XOR - 86)) |
-              (1 << (CypherParser.AND - 86)) |
-              (1 << (CypherParser.NOT - 86)) |
-              (1 << (CypherParser.STARTS - 86)) |
-              (1 << (CypherParser.ENDS - 86)) |
-              (1 << (CypherParser.CONTAINS - 86)) |
-              (1 << (CypherParser.NULL - 86)) |
-              (1 << (CypherParser.COUNT - 86)) |
-              (1 << (CypherParser.FILTER - 86)) |
-              (1 << (CypherParser.EXTRACT - 86)))) !==
-            0) ||
-        (((_la - 118) & ~0x1f) == 0 &&
-          ((1 << (_la - 118)) &
-            ((1 << (CypherParser.ANY - 118)) |
-              (1 << (CypherParser.NONE - 118)) |
-              (1 << (CypherParser.SINGLE - 118)) |
-              (1 << (CypherParser.TRUE - 118)) |
-              (1 << (CypherParser.FALSE - 118)) |
-              (1 << (CypherParser.REDUCE - 118)) |
-              (1 << (CypherParser.CASE - 118)) |
-              (1 << (CypherParser.ELSE - 118)) |
-              (1 << (CypherParser.END - 118)) |
-              (1 << (CypherParser.WHEN - 118)) |
-              (1 << (CypherParser.THEN - 118)) |
-              (1 << (CypherParser.CALL - 118)) |
-              (1 << (CypherParser.YIELD - 118)) |
-              (1 << (CypherParser.KEY - 118)))) !==
-            0)
-      )
-    ) {
-      this._errHandler.recoverInline(this)
-    } else {
-      this._errHandler.reportMatch(this)
-      this.consume()
-    }
-  } catch (re) {
-    if (re instanceof antlr4.error.RecognitionException) {
-      localctx.exception = re
-      this._errHandler.reportError(this, re)
-      this._errHandler.recover(this, re)
-    } else {
-      throw re
-    }
-  } finally {
-    this.exitRule()
-  }
-  return localctx
-}
-
-exports.CypherParser = CypherParser
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts b/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
index ed3d4cbee37..1615a6f818e 100644
--- a/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
+++ b/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
@@ -88,7 +88,6 @@ export function tokensForLine(input: string): monaco.languages.ILineTokens {
     myTokens.push(new CypherToken('error.cypher', e))
   }
   myTokens.sort((a, b) => (a.startIndex > b.startIndex ? 1 : -1))
-  console.log(myTokens)
 
   return new CypherLineTokens(myTokens)
 }
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts b/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
index 0adab165dba..f1ae2fda121 100644
--- a/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
+++ b/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import {
   CommonTokenStream,
   InputStream,
@@ -8,8 +7,8 @@ import {
   Lexer
 } from 'antlr4/index.js'
 // import { DefaultErrorStrategy } from 'antlr4/error/ErrorStrategy.js'
-import { CypherLexer } from './CypherLexer'
-import { CypherParser } from './CypherParser'
+
+import { CypherLexer, CypherParser } from 'cypher-editor-support'
 
 // class ConsoleErrorListener extends error.ErrorListener {
 //   syntaxError(_recognizer: any, _offendingSymbol: any, _line: any, _column: any, msg: string) {
@@ -56,11 +55,11 @@ export class Error {
 //   }
 // }
 
-export function createLexer(input: string) {
+export function createLexer(input: string): CypherLexer {
   const chars = new InputStream(input)
-  const lexer = new CypherLexer(chars) as any
+  const lexer = new CypherLexer(chars)
 
-  lexer.strictMode = false
+  // lexer.strictMode = false
 
   return lexer
 }
@@ -86,19 +85,19 @@ function createParserFromLexer(lexer: Lexer) {
 //   return parser.compilationUnit()
 // }
 
-export function parseTreeStr(input: string) {
-  const lexer = createLexer(input)
-  lexer.removeErrorListeners()
-  // lexer.addErrorListener(new ConsoleErrorListener())
+// export function parseTreeStr(input: string) {
+//   const lexer = createLexer(input)
+//   lexer.removeErrorListeners()
+//   lexer.addErrorListener(new ConsoleErrorListener())
 
-  const parser = createParserFromLexer(lexer) as any
-  parser.removeErrorListeners()
-  // parser.addErrorListener(new ConsoleErrorListener())
+//   const parser = createParserFromLexer(lexer as any)
+//   parser.removeErrorListeners()
+//   parser.addErrorListener(new ConsoleErrorListener())
 
-  const tree = parser.compilationUnit()
+//   const tree = parser.compilationUnit()
 
-  return tree.tostringTree(parser.ruleNames)
-}
+//   return tree.tostringTree(parser.ruleNames)
+// }
 
 // class CypherErrorStrategy extends DefaultErrorStrategy {
 //   reportUnwantedToken(recognizer: Parser) {
@@ -138,11 +137,11 @@ export function validate(input: string): Error[] {
   lexer.removeErrorListeners()
   // lexer.addErrorListener(new ConsoleErrorListener())
 
-  const parser = createParserFromLexer(lexer) as any
+  const parser = createParserFromLexer(lexer as any)
   parser.removeErrorListeners()
   // parser.addErrorListener(new CollectorErrorListener(errors))
   // parser._errHandler = new CypherErrorStrategy()
 
-  parser.compilationUnit()
+  // parser.compilationUnit()
   return errors
 }
diff --git a/yarn.lock b/yarn.lock
index 4c45333ee04..e8fa3e6ba66 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4592,7 +4592,7 @@ cypher-codemirror@1.1.6:
   dependencies:
     cypher-editor-support "1.1.6"
 
-cypher-editor-support@1.1.6:
+cypher-editor-support@1.1.6, cypher-editor-support@^1.1.6:
   version "1.1.6"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/cypher-editor-support/-/cypher-editor-support-1.1.6.tgz#a9bad1e9c67a91d8bcd7066e0498130de43ed84a"
   integrity sha1-qbrR6cZ6kdi81wZuBJgTDeQ+2Eo=

From cbf0ce0ade6ed550b88b38e374dbe0bc722ee288 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Mon, 5 Oct 2020 14:33:49 +0200
Subject: [PATCH 13/23] display notifications from EXPLAIN queries as squiggly
 lines

---
 src/browser/custom.d.ts                       | 18 +++--
 src/browser/modules/Editor/Editor.jsx         |  2 +-
 src/browser/modules/Editor/Monaco.tsx         | 68 ++++++++++++++++++-
 .../antlr-cypher-parser/ParserFacade.ts       |  3 +-
 src/browser/modules/Stream/EditFrame.tsx      |  4 +-
 5 files changed, 85 insertions(+), 10 deletions(-)

diff --git a/src/browser/custom.d.ts b/src/browser/custom.d.ts
index acc30e339ef..6e415a12f31 100644
--- a/src/browser/custom.d.ts
+++ b/src/browser/custom.d.ts
@@ -39,8 +39,8 @@ declare module 'suber' {
   export { Bus, createBus }
 }
 
-declare module 'cypher-editor-support' {
-  class CypherLexer extends (await import('antlr4/index.js')).Lexer {
+declare module 'cypher-editor-support/src/_generated/CypherLexer' {
+  export class CypherLexer extends (await import('antlr4/index.js')).Lexer {
     constructor(input: unknown)
     channelNames: string[]
     modeNames: string[]
@@ -50,11 +50,21 @@ declare module 'cypher-editor-support' {
     grammarFileName: string;
     [key: string]: number
   }
+}
 
-  class CypherParser extends (await import('antlr4/index.js')).Parser {
+declare module 'cypher-editor-support/src/_generated/CypherParser' {
+  export class CypherParser extends (await import('antlr4/index.js')).Parser {
     constructor(input: unknown)
     ruleNames: string[]
   }
+}
 
-  export { CypherLexer, CypherParser }
+declare module 'cypher-editor-support' {
+  export function parse(
+    input: string
+  ): {
+    referencesListener: {
+      queriesAndCommands: { getText: () => string; start: { line: number } }[]
+    }
+  }
 }
diff --git a/src/browser/modules/Editor/Editor.jsx b/src/browser/modules/Editor/Editor.jsx
index 1714c751e17..c0ef73b6e6d 100644
--- a/src/browser/modules/Editor/Editor.jsx
+++ b/src/browser/modules/Editor/Editor.jsx
@@ -64,7 +64,7 @@ import {
   EXECUTE_COMMAND_ORIGINS
 } from 'browser/modules/Sidebar/project-files.constants'
 
-const shouldCheckForHints = code =>
+export const shouldCheckForHints = code =>
   code.trim().length > 0 &&
   !code.trimLeft().startsWith(':') &&
   !code
diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index c94a22027f3..dfcbe205e5f 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -18,9 +18,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+import { parse } from 'cypher-editor-support'
 import * as monaco from 'monaco-editor'
 import React, { useEffect, useRef } from 'react'
+import { withBus } from 'react-suber'
+import { Bus } from 'suber'
+import { NEO4J_BROWSER_USER_ACTION_QUERY } from 'services/bolt/txMetadata'
+import { CYPHER_REQUEST } from 'shared/modules/cypher/cypherDuck'
 import { CypherTokensProvider } from './antlr-cypher-parser/CypherTokensProvider'
+import { shouldCheckForHints } from './Editor'
 
 export const VS_LIGHT_THEME = 'vs'
 export const VS_DARK_THEME = 'vs-dark'
@@ -32,6 +38,7 @@ export type VSTheme =
   | typeof VS_HIGH_CONTRAST_THEME
 
 interface MonacoProps {
+  bus: Bus
   id: string
   value?: string
   onChange?: (value: string) => void
@@ -40,6 +47,7 @@ interface MonacoProps {
 }
 
 const Monaco = ({
+  bus,
   id,
   value = '',
   onChange = () => undefined,
@@ -211,7 +219,15 @@ const Monaco = ({
     )
 
     editorRef.current?.onDidChangeModelContent(() => {
-      onChange(editorRef.current?.getValue() || '')
+      const text =
+        editorRef.current
+          ?.getModel()
+          ?.getLinesContent()
+          .join('\n') || ''
+
+      const { queriesAndCommands } = parse(text).referencesListener
+      onChange(text)
+      checkForHints(queriesAndCommands)
     })
 
     return () => {
@@ -223,6 +239,54 @@ const Monaco = ({
     monaco.editor.setTheme(theme)
   }, [theme])
 
+  const checkForHints = (
+    statements: { start: { line: number }; getText: () => string }[]
+  ) => {
+    if (!statements.length) return
+    statements.forEach(stmt => {
+      const text = stmt.getText()
+      if (!shouldCheckForHints(text)) {
+        return
+      }
+      const statementLineNumber = stmt.start.line - 1
+
+      bus.self(
+        CYPHER_REQUEST,
+        {
+          query: 'EXPLAIN ' + text,
+          queryType: NEO4J_BROWSER_USER_ACTION_QUERY
+        },
+        response => {
+          if (
+            response.success === true &&
+            response.result.summary.notifications.length > 0
+          ) {
+            monaco.editor.setModelMarkers(
+              editorRef.current?.getModel() as monaco.editor.ITextModel,
+              monacoId,
+              response.result.summary.notifications.map(
+                ({
+                  position: { offset, line, column },
+                  title
+                }: {
+                  position: any
+                  title: string
+                }) => ({
+                  startLineNumber: statementLineNumber + line,
+                  startColumn: column - offset,
+                  endLineNumber: statementLineNumber + line,
+                  endColumn: 1000,
+                  message: title,
+                  severity: monaco.MarkerSeverity.Warning
+                })
+              )
+            )
+          }
+        }
+      )
+    })
+  }
+
   return (
     <div
       id={monacoId}
@@ -234,4 +298,4 @@ const Monaco = ({
   )
 }
 
-export default Monaco
+export default withBus(Monaco)
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts b/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
index f1ae2fda121..68026141027 100644
--- a/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
+++ b/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
@@ -8,7 +8,8 @@ import {
 } from 'antlr4/index.js'
 // import { DefaultErrorStrategy } from 'antlr4/error/ErrorStrategy.js'
 
-import { CypherLexer, CypherParser } from 'cypher-editor-support'
+import { CypherLexer } from 'cypher-editor-support/src/_generated/CypherLexer'
+import { CypherParser } from 'cypher-editor-support/src/_generated/CypherParser'
 
 // class ConsoleErrorListener extends error.ErrorListener {
 //   syntaxError(_recognizer: any, _offendingSymbol: any, _line: any, _column: any, msg: string) {
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index a2040c470a8..a2692a1c289 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -18,11 +18,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-// import * as antlr4 from 'antlr4'
 import React, { Dispatch, useEffect, useState } from 'react'
 import { connect } from 'react-redux'
 import { Action } from 'redux'
 import styled from 'styled-components'
+
 import Monaco, {
   VS_DARK_THEME,
   VS_HIGH_CONTRAST_THEME,
@@ -31,6 +31,7 @@ import Monaco, {
 } from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
 import { StyledFrameBody } from '../Frame/styled'
+import useDerivedTheme from 'browser-hooks/useDerivedTheme'
 import { executeCommand } from 'shared/modules/commands/commandsDuck'
 import {
   DARK_THEME,
@@ -39,7 +40,6 @@ import {
   OUTLINE_THEME
 } from 'shared/modules/settings/settingsDuck'
 import { Frame, GlobalState } from 'shared/modules/stream/streamDuck'
-import useDerivedTheme from 'browser-hooks/useDerivedTheme'
 
 export type BrowserTheme =
   | typeof LIGHT_THEME

From 9d1e6f10fdb6e56e5a2277aa1d706a5894fc21be Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Tue, 6 Oct 2020 10:15:10 +0200
Subject: [PATCH 14/23] trigger explain query on monaco component creation

---
 src/browser/modules/Editor/Monaco.tsx | 31 +++++++++++++++------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index dfcbe205e5f..fb4ae37bd4d 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -185,7 +185,6 @@ const Monaco = ({
       { token: 'stringliteral.cypher', foreground: Color.yellow }
     ]
 
-    // Use colors and rules, only add default foreground and background colors
     monaco.editor.defineTheme(VS_LIGHT_THEME, {
       base: VS_LIGHT_THEME,
       inherit: false,
@@ -218,17 +217,9 @@ const Monaco = ({
       }
     )
 
-    editorRef.current?.onDidChangeModelContent(() => {
-      const text =
-        editorRef.current
-          ?.getModel()
-          ?.getLinesContent()
-          .join('\n') || ''
+    updateCode()
 
-      const { queriesAndCommands } = parse(text).referencesListener
-      onChange(text)
-      checkForHints(queriesAndCommands)
-    })
+    editorRef.current?.onDidChangeModelContent(updateCode)
 
     return () => {
       editorRef.current?.dispose()
@@ -239,6 +230,18 @@ const Monaco = ({
     monaco.editor.setTheme(theme)
   }, [theme])
 
+  const updateCode = () => {
+    const text =
+      editorRef.current
+        ?.getModel()
+        ?.getLinesContent()
+        .join('\n') || ''
+
+    const { queriesAndCommands } = parse(text).referencesListener
+    onChange(text)
+    checkForHints(queriesAndCommands)
+  }
+
   const checkForHints = (
     statements: { start: { line: number }; getText: () => string }[]
   ) => {
@@ -266,14 +269,14 @@ const Monaco = ({
               monacoId,
               response.result.summary.notifications.map(
                 ({
-                  position: { offset, line, column },
+                  position: { line },
                   title
                 }: {
-                  position: any
+                  position: { line: number }
                   title: string
                 }) => ({
                   startLineNumber: statementLineNumber + line,
-                  startColumn: column - offset,
+                  startColumn: 1,
                   endLineNumber: statementLineNumber + line,
                   endColumn: 1000,
                   message: title,

From f089742e25047aac25e6071950a65f381fb8f361 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Tue, 6 Oct 2020 11:59:08 +0200
Subject: [PATCH 15/23] include full notification description in hover modal

---
 src/browser/modules/Editor/Monaco.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index fb4ae37bd4d..f941c1984f0 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -269,9 +269,11 @@ const Monaco = ({
               monacoId,
               response.result.summary.notifications.map(
                 ({
+                  description,
                   position: { line },
                   title
                 }: {
+                  description: string
                   position: { line: number }
                   title: string
                 }) => ({
@@ -279,7 +281,7 @@ const Monaco = ({
                   startColumn: 1,
                   endLineNumber: statementLineNumber + line,
                   endColumn: 1000,
-                  message: title,
+                  message: title + '\n\n' + description,
                   severity: monaco.MarkerSeverity.Warning
                 })
               )

From f14bf8b907a53ba257294d20c35fcc1aa7c9cd5a Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Tue, 6 Oct 2020 15:26:35 +0200
Subject: [PATCH 16/23] debounce EXPLAIN query calls

---
 src/browser/modules/Editor/Monaco.tsx | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index f941c1984f0..0655a85692d 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -19,6 +19,7 @@
  */
 
 import { parse } from 'cypher-editor-support'
+import { debounce } from 'lodash-es'
 import * as monaco from 'monaco-editor'
 import React, { useEffect, useRef } from 'react'
 import { withBus } from 'react-suber'
@@ -217,9 +218,9 @@ const Monaco = ({
       }
     )
 
-    updateCode()
+    onContentUpdate()
 
-    editorRef.current?.onDidChangeModelContent(updateCode)
+    editorRef.current?.onDidChangeModelContent(onContentUpdate)
 
     return () => {
       editorRef.current?.dispose()
@@ -242,6 +243,17 @@ const Monaco = ({
     checkForHints(queriesAndCommands)
   }
 
+  const onContentUpdate = () => {
+    monaco.editor.setModelMarkers(
+      editorRef.current?.getModel() as monaco.editor.ITextModel,
+      monacoId,
+      []
+    )
+    debouncedUpdateCode()
+  }
+
+  const debouncedUpdateCode = debounce(updateCode, 300)
+
   const checkForHints = (
     statements: { start: { line: number }; getText: () => string }[]
   ) => {

From 437e4cb728a2de8c89643af3d11978001a67b1f9 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Wed, 7 Oct 2020 15:36:54 +0200
Subject: [PATCH 17/23] display multi statement warning

---
 src/browser/modules/Editor/Monaco.tsx    | 38 +++++++++++++++++++-----
 src/browser/modules/Stream/EditFrame.tsx |  8 +++--
 2 files changed, 36 insertions(+), 10 deletions(-)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index 0655a85692d..3e813b3e138 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -40,6 +40,7 @@ export type VSTheme =
 
 interface MonacoProps {
   bus: Bus
+  enableMultiStatementMode: boolean
   id: string
   value?: string
   onChange?: (value: string) => void
@@ -49,6 +50,7 @@ interface MonacoProps {
 
 const Monaco = ({
   bus,
+  enableMultiStatementMode = true,
   id,
   value = '',
   onChange = () => undefined,
@@ -231,6 +233,10 @@ const Monaco = ({
     monaco.editor.setTheme(theme)
   }, [theme])
 
+  useEffect(() => {
+    onContentUpdate()
+  }, [enableMultiStatementMode])
+
   const updateCode = () => {
     const text =
       editorRef.current
@@ -258,12 +264,29 @@ const Monaco = ({
     statements: { start: { line: number }; getText: () => string }[]
   ) => {
     if (!statements.length) return
-    statements.forEach(stmt => {
-      const text = stmt.getText()
+
+    const model = editorRef.current?.getModel() as monaco.editor.ITextModel
+    if (statements.length > 1 && !enableMultiStatementMode) {
+      const secondStatementLine = statements[1].start.line
+      monaco.editor.setModelMarkers(model, monacoId, [
+        {
+          startLineNumber: secondStatementLine,
+          startColumn: 1,
+          endLineNumber: secondStatementLine,
+          endColumn: 1000,
+          message:
+            'To use multi statement queries, please enable multi statement in the settings panel.',
+          severity: monaco.MarkerSeverity.Warning
+        }
+      ])
+    }
+
+    statements.forEach(statement => {
+      const text = statement.getText()
       if (!shouldCheckForHints(text)) {
         return
       }
-      const statementLineNumber = stmt.start.line - 1
+      const statementLineNumber = statement.start.line - 1
 
       bus.self(
         CYPHER_REQUEST,
@@ -276,10 +299,9 @@ const Monaco = ({
             response.success === true &&
             response.result.summary.notifications.length > 0
           ) {
-            monaco.editor.setModelMarkers(
-              editorRef.current?.getModel() as monaco.editor.ITextModel,
-              monacoId,
-              response.result.summary.notifications.map(
+            monaco.editor.setModelMarkers(model, monacoId, [
+              ...monaco.editor.getModelMarkers({ owner: monacoId }),
+              ...response.result.summary.notifications.map(
                 ({
                   description,
                   position: { line },
@@ -297,7 +319,7 @@ const Monaco = ({
                   severity: monaco.MarkerSeverity.Warning
                 })
               )
-            )
+            ])
           }
         }
       )
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index a2692a1c289..4563ea264f5 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -37,7 +37,8 @@ import {
   DARK_THEME,
   getTheme,
   LIGHT_THEME,
-  OUTLINE_THEME
+  OUTLINE_THEME,
+  shouldEnableMultiStatementMode
 } from 'shared/modules/settings/settingsDuck'
 import { Frame, GlobalState } from 'shared/modules/stream/streamDuck'
 
@@ -48,6 +49,7 @@ export type BrowserTheme =
 
 interface EditFrameProps {
   browserTheme: BrowserTheme
+  enableMultiStatementMode: boolean
   frame: Frame
   runQuery: (query: string) => void
 }
@@ -81,6 +83,7 @@ const EditFrame = (props: EditFrameProps): JSX.Element => {
         contents={
           <Monaco
             id={props.frame.id}
+            enableMultiStatementMode={props.enableMultiStatementMode}
             onChange={setText}
             theme={theme}
             value={text}
@@ -96,7 +99,8 @@ const EditFrame = (props: EditFrameProps): JSX.Element => {
 }
 
 const mapStateToProps = (state: GlobalState) => ({
-  browserTheme: getTheme(state)
+  browserTheme: getTheme(state),
+  enableMultiStatementMode: shouldEnableMultiStatementMode(state)
 })
 
 const mapDispatchToProps = (dispatch: Dispatch<Action>) => ({

From a8fcac979346fe1b48d1b88f44e614ae92c65590 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Wed, 7 Oct 2020 20:41:01 +0200
Subject: [PATCH 18/23] clean up monaco editor implementation

---
 src/browser/custom.d.ts                       |   7 -
 .../modules/Editor/CypherTokensProvider.ts    |  60 +++++++
 src/browser/modules/Editor/Monaco.tsx         |  43 ++---
 .../CypherTokensProvider.ts                   |  93 -----------
 .../antlr-cypher-parser/ParserFacade.ts       | 148 ------------------
 src/browser/modules/Stream/EditFrame.tsx      |  26 +--
 .../services/commandInterpreterHelper.js      |   2 +-
 7 files changed, 89 insertions(+), 290 deletions(-)
 create mode 100644 src/browser/modules/Editor/CypherTokensProvider.ts
 delete mode 100644 src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
 delete mode 100644 src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts

diff --git a/src/browser/custom.d.ts b/src/browser/custom.d.ts
index 6e415a12f31..7c7849c9ee7 100644
--- a/src/browser/custom.d.ts
+++ b/src/browser/custom.d.ts
@@ -52,13 +52,6 @@ declare module 'cypher-editor-support/src/_generated/CypherLexer' {
   }
 }
 
-declare module 'cypher-editor-support/src/_generated/CypherParser' {
-  export class CypherParser extends (await import('antlr4/index.js')).Parser {
-    constructor(input: unknown)
-    ruleNames: string[]
-  }
-}
-
 declare module 'cypher-editor-support' {
   export function parse(
     input: string
diff --git a/src/browser/modules/Editor/CypherTokensProvider.ts b/src/browser/modules/Editor/CypherTokensProvider.ts
new file mode 100644
index 00000000000..bf0ee93f5cb
--- /dev/null
+++ b/src/browser/modules/Editor/CypherTokensProvider.ts
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { InputStream } from 'antlr4/index.js'
+import { CypherLexer } from 'cypher-editor-support/src/_generated/CypherLexer'
+import * as monaco from 'monaco-editor'
+
+class CypherState implements monaco.languages.IState {
+  clone() {
+    return new CypherState()
+  }
+
+  equals() {
+    return true
+  }
+}
+
+export class CypherTokensProvider implements monaco.languages.TokensProvider {
+  getInitialState(): CypherState {
+    return new CypherState()
+  }
+
+  tokenize(line: string): monaco.languages.ILineTokens {
+    const lexer = new CypherLexer(new InputStream(line))
+
+    return {
+      endState: new CypherState(),
+      tokens: lexer
+        .getAllTokens()
+        .filter(token => token !== null && token.type !== -1)
+        .map(token => ({
+          scopes:
+            (
+              lexer.symbolicNames[token.type] ??
+              lexer.literalNames[token.type] ??
+              ''
+            ).toLowerCase() + '.cypher',
+          startIndex: token.column
+        }))
+        .sort((a, b) => (a.startIndex > b.startIndex ? 1 : -1))
+    }
+  }
+}
diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index 3e813b3e138..1977a88af3b 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -26,26 +26,27 @@ import { withBus } from 'react-suber'
 import { Bus } from 'suber'
 import { NEO4J_BROWSER_USER_ACTION_QUERY } from 'services/bolt/txMetadata'
 import { CYPHER_REQUEST } from 'shared/modules/cypher/cypherDuck'
-import { CypherTokensProvider } from './antlr-cypher-parser/CypherTokensProvider'
+import {
+  DARK_THEME,
+  LIGHT_THEME,
+  OUTLINE_THEME
+} from 'shared/modules/settings/settingsDuck'
+import { CypherTokensProvider } from './CypherTokensProvider'
 import { shouldCheckForHints } from './Editor'
 
-export const VS_LIGHT_THEME = 'vs'
-export const VS_DARK_THEME = 'vs-dark'
-export const VS_HIGH_CONTRAST_THEME = 'hc-black'
-
-export type VSTheme =
-  | typeof VS_LIGHT_THEME
-  | typeof VS_DARK_THEME
-  | typeof VS_HIGH_CONTRAST_THEME
+type BrowserTheme =
+  | typeof LIGHT_THEME
+  | typeof OUTLINE_THEME
+  | typeof DARK_THEME
 
 interface MonacoProps {
   bus: Bus
-  enableMultiStatementMode: boolean
+  enableMultiStatementMode?: boolean
   id: string
   value?: string
   onChange?: (value: string) => void
   options?: monaco.editor.IGlobalEditorOptions
-  theme?: VSTheme
+  theme?: BrowserTheme
 }
 
 const Monaco = ({
@@ -54,7 +55,7 @@ const Monaco = ({
   id,
   value = '',
   onChange = () => undefined,
-  theme = VS_LIGHT_THEME
+  theme = LIGHT_THEME
 }: MonacoProps): JSX.Element => {
   const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
   const monacoId = `monaco-${id}`
@@ -188,14 +189,14 @@ const Monaco = ({
       { token: 'stringliteral.cypher', foreground: Color.yellow }
     ]
 
-    monaco.editor.defineTheme(VS_LIGHT_THEME, {
-      base: VS_LIGHT_THEME,
+    monaco.editor.defineTheme(LIGHT_THEME, {
+      base: 'vs',
       inherit: false,
       rules: [...rules, { token: 'sp.cypher', foreground: Color.light_grey }],
       colors: {}
     })
-    monaco.editor.defineTheme(VS_DARK_THEME, {
-      base: VS_DARK_THEME,
+    monaco.editor.defineTheme(DARK_THEME, {
+      base: 'vs-dark',
       inherit: false,
       rules: [...rules, { token: 'sp.cypher', foreground: Color.cyan_grey }],
       colors: {}
@@ -214,7 +215,7 @@ const Monaco = ({
         minimap: { enabled: false },
         scrollBeyondLastColumn: 0,
         scrollBeyondLastLine: false,
-        theme: VS_LIGHT_THEME,
+        theme: LIGHT_THEME,
         value,
         wordWrap: 'on'
       }
@@ -244,9 +245,8 @@ const Monaco = ({
         ?.getLinesContent()
         .join('\n') || ''
 
-    const { queriesAndCommands } = parse(text).referencesListener
     onChange(text)
-    checkForHints(queriesAndCommands)
+    addWarnings(parse(text).referencesListener.queriesAndCommands)
   }
 
   const onContentUpdate = () => {
@@ -260,12 +260,14 @@ const Monaco = ({
 
   const debouncedUpdateCode = debounce(updateCode, 300)
 
-  const checkForHints = (
+  const addWarnings = (
     statements: { start: { line: number }; getText: () => string }[]
   ) => {
     if (!statements.length) return
 
     const model = editorRef.current?.getModel() as monaco.editor.ITextModel
+
+    // add multi statement warning if multi setting is off
     if (statements.length > 1 && !enableMultiStatementMode) {
       const secondStatementLine = statements[1].start.line
       monaco.editor.setModelMarkers(model, monacoId, [
@@ -281,6 +283,7 @@ const Monaco = ({
       ])
     }
 
+    // add a warning for each notification returned by explain query
     statements.forEach(statement => {
       const text = statement.getText()
       if (!shouldCheckForHints(text)) {
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts b/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
deleted file mode 100644
index 1615a6f818e..00000000000
--- a/src/browser/modules/Editor/antlr-cypher-parser/CypherTokensProvider.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import * as monaco from 'monaco-editor'
-import { createLexer } from './ParserFacade'
-import ILineTokens = monaco.languages.ILineTokens
-import IToken = monaco.languages.IToken
-
-export class CypherState implements monaco.languages.IState {
-  clone(): monaco.languages.IState {
-    return new CypherState()
-  }
-
-  equals(): boolean {
-    return true
-  }
-}
-
-export class CypherTokensProvider implements monaco.languages.TokensProvider {
-  getInitialState(): monaco.languages.IState {
-    return new CypherState()
-  }
-
-  tokenize(line: string): monaco.languages.ILineTokens {
-    // So far we ignore the state, which is not great for performance reasons
-    return tokensForLine(line)
-  }
-}
-
-const EOF = -1
-
-class CypherToken implements IToken {
-  scopes: string
-  startIndex: number
-
-  constructor(ruleName: string, startIndex: number) {
-    if (ruleName === null) {
-      ruleName = ''
-    }
-    this.scopes = ruleName.toLowerCase() + '.cypher'
-    this.startIndex = startIndex
-  }
-}
-
-class CypherLineTokens implements ILineTokens {
-  endState: monaco.languages.IState
-  tokens: monaco.languages.IToken[]
-
-  constructor(tokens: monaco.languages.IToken[]) {
-    this.endState = new CypherState()
-    this.tokens = tokens
-  }
-}
-
-export function tokensForLine(input: string): monaco.languages.ILineTokens {
-  const errorStartingPoints: number[] = []
-
-  // class ErrorCollectorListener extends error.ErrorListener {
-  //     syntaxError(_recognizer, _offendingSymbol, _line, column, _msg, _e) {
-  //         errorStartingPoints.push(column)
-  //     }
-  // }
-
-  const lexer = createLexer(input)
-  lexer.removeErrorListeners()
-  // let errorListener = new ErrorCollectorListener();
-  // lexer.addErrorListener(errorListener);
-  let done = false
-  const myTokens: monaco.languages.IToken[] = []
-  do {
-    const token = lexer.nextToken()
-    if (token == null) {
-      done = true
-    } else {
-      // We exclude EOF
-      if (token.type == EOF) {
-        done = true
-      } else {
-        let tokenTypeName = lexer.symbolicNames[token.type]
-        if (tokenTypeName === null) {
-          tokenTypeName = lexer.literalNames[token.type]
-        }
-        const myToken = new CypherToken(tokenTypeName, token.column)
-        myTokens.push(myToken)
-      }
-    }
-  } while (!done)
-
-  // Add all errors
-  for (const e of errorStartingPoints) {
-    myTokens.push(new CypherToken('error.cypher', e))
-  }
-  myTokens.sort((a, b) => (a.startIndex > b.startIndex ? 1 : -1))
-
-  return new CypherLineTokens(myTokens)
-}
diff --git a/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts b/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
deleted file mode 100644
index 68026141027..00000000000
--- a/src/browser/modules/Editor/antlr-cypher-parser/ParserFacade.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import {
-  CommonTokenStream,
-  InputStream,
-  Token,
-  // error,
-  // Parser,
-  Lexer
-} from 'antlr4/index.js'
-// import { DefaultErrorStrategy } from 'antlr4/error/ErrorStrategy.js'
-
-import { CypherLexer } from 'cypher-editor-support/src/_generated/CypherLexer'
-import { CypherParser } from 'cypher-editor-support/src/_generated/CypherParser'
-
-// class ConsoleErrorListener extends error.ErrorListener {
-//   syntaxError(_recognizer: any, _offendingSymbol: any, _line: any, _column: any, msg: string) {
-//     console.log('ERROR ' + msg)
-//   }
-// }
-
-export class Error {
-  startLine: number
-  endLine: number
-  startCol: number
-  endCol: number
-  message: string
-
-  constructor(
-    startLine: number,
-    endLine: number,
-    startCol: number,
-    endCol: number,
-    message: string
-  ) {
-    this.startLine = startLine
-    this.endLine = endLine
-    this.startCol = startCol
-    this.endCol = endCol
-    this.message = message
-  }
-}
-
-// class CollectorErrorListener extends error.ErrorListener {
-//   private errors: Error[] = []
-
-//   constructor(errors: Error[]) {
-//     super()
-//     this.errors = errors
-//   }
-
-//   syntaxError(_recognizer: any, offendingSymbol: { _text: string | any[] | null }, line: number, column: number, msg: string) {
-//     let endColumn = column + 1
-//     if (offendingSymbol._text !== null) {
-//       endColumn = column + offendingSymbol._text.length
-//     }
-//     this.errors.push(new Error(line, line, column, endColumn, msg))
-//   }
-// }
-
-export function createLexer(input: string): CypherLexer {
-  const chars = new InputStream(input)
-  const lexer = new CypherLexer(chars)
-
-  // lexer.strictMode = false
-
-  return lexer
-}
-
-export function getTokens(input: string): Token[] {
-  return createLexer(input).getAllTokens()
-}
-
-// function createParser(input: string) {
-//   const lexer = createLexer(input)
-
-//   return createParserFromLexer(lexer)
-// }
-
-function createParserFromLexer(lexer: Lexer) {
-  const tokens = new CommonTokenStream(lexer)
-  return new CypherParser(tokens)
-}
-
-// function parseTree(input: any) {
-//   const parser = createParser(input)
-
-//   return parser.compilationUnit()
-// }
-
-// export function parseTreeStr(input: string) {
-//   const lexer = createLexer(input)
-//   lexer.removeErrorListeners()
-//   lexer.addErrorListener(new ConsoleErrorListener())
-
-//   const parser = createParserFromLexer(lexer as any)
-//   parser.removeErrorListeners()
-//   parser.addErrorListener(new ConsoleErrorListener())
-
-//   const tree = parser.compilationUnit()
-
-//   return tree.tostringTree(parser.ruleNames)
-// }
-
-// class CypherErrorStrategy extends DefaultErrorStrategy {
-//   reportUnwantedToken(recognizer: Parser) {
-//     return super.reportUnwantedToken(recognizer)
-//   }
-
-//   singleTokenDeletion(recognizer: Parser) {
-//     const nextTokenType = recognizer.getTokenStream().LA(2)
-//     if (recognizer.getTokenStream().LA(1) == CypherParser.NL) {
-//       return null
-//     }
-//     const expecting = this.getExpectedTokens(recognizer)
-//     if (expecting.contains(nextTokenType)) {
-//       this.reportUnwantedToken(recognizer)
-//       recognizer.consume() // simply delete extra token
-//       // we want to return the token we're actually matching
-//       const matchedSymbol = recognizer.getCurrentToken()
-//       this.reportMatch(recognizer) // we know current token is correct
-//       return matchedSymbol
-//     } else {
-//       return null
-//     }
-//   }
-//   getExpectedTokens = function(recognizer: { getExpectedTokens: () => any }) {
-//     return recognizer.getExpectedTokens()
-//   }
-
-//   reportMatch = function(recognizer: any) {
-//     this.endErrorCondition(recognizer)
-//   }
-// }
-
-export function validate(input: string): Error[] {
-  const errors: Error[] = []
-
-  const lexer = createLexer(input)
-  lexer.removeErrorListeners()
-  // lexer.addErrorListener(new ConsoleErrorListener())
-
-  const parser = createParserFromLexer(lexer as any)
-  parser.removeErrorListeners()
-  // parser.addErrorListener(new CollectorErrorListener(errors))
-  // parser._errHandler = new CypherErrorStrategy()
-
-  // parser.compilationUnit()
-  return errors
-}
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index 4563ea264f5..6cc53ee4bec 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -18,17 +18,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import React, { Dispatch, useEffect, useState } from 'react'
+import React, { Dispatch, useState } from 'react'
 import { connect } from 'react-redux'
 import { Action } from 'redux'
 import styled from 'styled-components'
 
-import Monaco, {
-  VS_DARK_THEME,
-  VS_HIGH_CONTRAST_THEME,
-  VS_LIGHT_THEME,
-  VSTheme
-} from '../Editor/Monaco'
+import Monaco from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
 import { StyledFrameBody } from '../Frame/styled'
 import useDerivedTheme from 'browser-hooks/useDerivedTheme'
@@ -42,7 +37,7 @@ import {
 } from 'shared/modules/settings/settingsDuck'
 import { Frame, GlobalState } from 'shared/modules/stream/streamDuck'
 
-export type BrowserTheme =
+type BrowserTheme =
   | typeof LIGHT_THEME
   | typeof OUTLINE_THEME
   | typeof DARK_THEME
@@ -66,16 +61,6 @@ const EditFrame = (props: EditFrameProps): JSX.Element => {
   const [derivedTheme] = useDerivedTheme(props.browserTheme, LIGHT_THEME) as [
     BrowserTheme
   ]
-  const [theme, setTheme] = useState<VSTheme>(VS_LIGHT_THEME)
-
-  useEffect(() => {
-    const themeMap: { [key in BrowserTheme]: VSTheme } = {
-      [LIGHT_THEME]: VS_LIGHT_THEME,
-      [OUTLINE_THEME]: VS_HIGH_CONTRAST_THEME,
-      [DARK_THEME]: VS_DARK_THEME
-    }
-    setTheme(themeMap[derivedTheme])
-  }, [derivedTheme])
 
   return (
     <ForceFullSizeFrameContent>
@@ -85,9 +70,9 @@ const EditFrame = (props: EditFrameProps): JSX.Element => {
             id={props.frame.id}
             enableMultiStatementMode={props.enableMultiStatementMode}
             onChange={setText}
-            theme={theme}
+            theme={derivedTheme}
             value={text}
-          ></Monaco>
+          />
         }
         header={props.frame}
         runQuery={() => {
@@ -106,7 +91,6 @@ const mapStateToProps = (state: GlobalState) => ({
 const mapDispatchToProps = (dispatch: Dispatch<Action>) => ({
   runQuery(query: string) {
     dispatch(executeCommand(query))
-    // TODO: dispatch update frame.query with text
   }
 })
 
diff --git a/src/shared/services/commandInterpreterHelper.js b/src/shared/services/commandInterpreterHelper.js
index cb1c6eddd00..2b4af29ec01 100644
--- a/src/shared/services/commandInterpreterHelper.js
+++ b/src/shared/services/commandInterpreterHelper.js
@@ -795,7 +795,7 @@ ${param}`)
       put(
         frames.add({
           ...action,
-          query: action.cmd.split(`${cmdchar}edit`)[1].trim(),
+          query: action.cmd.split(':edit')[1].trim(),
           type: 'edit'
         })
       )

From 3ccdbfcfa6edb85e8b6de5dd0723849fa955784c Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Thu, 8 Oct 2020 16:50:39 +0200
Subject: [PATCH 19/23] improve monaco editor theming

---
 .../modules/Editor/CypherMonacoThemes.ts      | 300 ++++++++++++++++++
 src/browser/modules/Editor/Monaco.tsx         | 164 ++--------
 src/browser/modules/Stream/EditFrame.tsx      |  12 +-
 3 files changed, 322 insertions(+), 154 deletions(-)
 create mode 100644 src/browser/modules/Editor/CypherMonacoThemes.ts

diff --git a/src/browser/modules/Editor/CypherMonacoThemes.ts b/src/browser/modules/Editor/CypherMonacoThemes.ts
new file mode 100644
index 00000000000..525e3e438e0
--- /dev/null
+++ b/src/browser/modules/Editor/CypherMonacoThemes.ts
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import * as monaco from 'monaco-editor'
+import { base } from 'browser-styles/themes'
+import {
+  LIGHT_THEME,
+  OUTLINE_THEME,
+  DARK_THEME
+} from 'shared/modules/settings/settingsDuck'
+
+export type BrowserTheme =
+  | typeof LIGHT_THEME
+  | typeof OUTLINE_THEME
+  | typeof DARK_THEME
+
+// colors from cypher-editor/cypher-codemirror/src/css/_solarized.css
+const enum CypherColor {
+  black = '#333333',
+  blue = '#268bd2',
+  cyan = '#2aa198',
+  cyan_grey = '#586e75',
+  green = '#859900',
+  light_grey = '#93a1a1',
+  magenta = '#d33682',
+  orange = '#cb4b16',
+  red = '#dc322f',
+  violet = '#6c71c4',
+  white = '#fdf6e3',
+  yellow = '#b58900'
+}
+
+const makeCypherTokenThemeRule = (token: string, foreground: CypherColor) => ({
+  token: `${token}.cypher`,
+  foreground
+})
+
+const comments: string[] = ['comment']
+const strings: string[] = ['stringliteral', 'urlhex']
+const numbers: string[] = [
+  'hexinteger',
+  'decimalinteger',
+  'octalinteger',
+  'hexletter',
+  'hexdigit',
+  'digit',
+  'nonzerodigit',
+  'nonzerooctdigit',
+  'octdigit',
+  'zerodigit',
+  'exponentdecimalreal',
+  'regulardecimalreal'
+]
+const operators: string[] = [
+  'identifierstart',
+  'identifierpart',
+  "';'",
+  "':'",
+  "'-'",
+  "'=>'",
+  "'://'",
+  "'/'",
+  "'.'",
+  "'@'",
+  "'#'",
+  "'?'",
+  "'&'",
+  "'='",
+  "'+'",
+  "'{'",
+  "','",
+  "'}'",
+  "'['",
+  "']'",
+  "'('",
+  "')'",
+  "'+='",
+  "'|'",
+  "'*'",
+  "'..'",
+  "'%'",
+  "'^'",
+  "'=~'",
+  "'<>'",
+  "'!='",
+  "'<'",
+  "'>'",
+  "'<='",
+  "'>='",
+  "'$'",
+  "'\u27E8'",
+  "'\u3008'",
+  "'\uFE64'",
+  "'\uFF1C'",
+  "'\u27E9'",
+  "'\u3009'",
+  "'\uFE65'",
+  "'\uFF1E'",
+  "'\u00AD'",
+  "'\u2010'",
+  "'\u2011'",
+  "'\u2012'",
+  "'\u2013'",
+  "'\u2014'",
+  "'\u2015'",
+  "'\u2212'",
+  "'\uFE58'",
+  "'\uFE63'",
+  "'\uFF0D'"
+]
+const keywords: string[] = [
+  'cypher',
+  'explain',
+  'profile',
+  'using',
+  'periodic',
+  'commit',
+  'union',
+  'all',
+  'create',
+  'drop',
+  'index',
+  'on',
+  'constraint',
+  'assert',
+  'is',
+  'unique',
+  'exists',
+  'load',
+  'csv',
+  'with',
+  'headers',
+  'from',
+  'as',
+  'fieldterminator',
+  'optional',
+  'match',
+  'unwind',
+  'merge',
+  'set',
+  'detach',
+  'delete',
+  'remove',
+  'foreach',
+  'in',
+  'distinct',
+  'return',
+  'order',
+  'by',
+  'l_skip',
+  'limit',
+  'ascending',
+  'asc',
+  'descending',
+  'desc',
+  'join',
+  'scan',
+  'start',
+  'node',
+  'relationship',
+  'rel',
+  'where',
+  'shortestpath',
+  'allshortestpaths',
+  'or',
+  'xor',
+  'and',
+  'not',
+  'starts',
+  'ends',
+  'contains',
+  'null',
+  'count',
+  'filter',
+  'extract',
+  'any',
+  'none',
+  'single',
+  'true',
+  'false',
+  'reduce',
+  'case',
+  'else',
+  'end',
+  'when',
+  'then',
+  'call',
+  'yield',
+  'key'
+]
+const labels: string[] = []
+const relationshipTypes: string[] = []
+const variables: string[] = []
+const procedures: string[] = []
+const functions: string[] = []
+const parameters: string[] = []
+const properties: string[] = []
+const consoleCommands: string[] = []
+const procedureOutput: string[] = []
+const tokensWithoutSyntaxHighlighting: string[] = [
+  'escapedchar',
+  'unescapedsymbolicname',
+  'escapedsymbolicname',
+  'sp',
+  'whitespace',
+  'error_token'
+]
+
+// syntax highlighting from cypher-editor/cypher-codemirror/src/css/syntax.css
+const sharedRules: monaco.editor.ITokenThemeRule[] = [
+  ...strings.map(token => makeCypherTokenThemeRule(token, CypherColor.yellow)),
+  ...numbers.map(token => makeCypherTokenThemeRule(token, CypherColor.cyan)),
+
+  ...keywords.map(token => makeCypherTokenThemeRule(token, CypherColor.green)),
+  ...labels.map(token => makeCypherTokenThemeRule(token, CypherColor.orange)),
+  ...relationshipTypes.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.orange)
+  ),
+  ...variables.map(token => makeCypherTokenThemeRule(token, CypherColor.blue)),
+  ...procedures.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.violet)
+  ),
+  ...functions.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.violet)
+  ),
+  ...parameters.map(token => makeCypherTokenThemeRule(token, CypherColor.red)),
+  ...consoleCommands.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.magenta)
+  ),
+  ...procedureOutput.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.blue)
+  )
+]
+const darkThemeRules = [
+  ...sharedRules,
+  ...comments.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.cyan_grey)
+  ),
+  ...properties.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.light_grey)
+  ),
+  ...tokensWithoutSyntaxHighlighting.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.white)
+  ),
+  ...operators.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.light_grey)
+  )
+]
+const lightThemeRules = [
+  ...sharedRules,
+  ...comments.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.light_grey)
+  ),
+  ...properties.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.cyan_grey)
+  ),
+  ...tokensWithoutSyntaxHighlighting.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.black)
+  ),
+  ...operators.map(token =>
+    makeCypherTokenThemeRule(token, CypherColor.cyan_grey)
+  )
+]
+
+export const monacoDarkTheme: monaco.editor.IStandaloneThemeData = {
+  base: 'vs-dark',
+  inherit: false,
+  rules: darkThemeRules,
+  colors: {
+    'editorLineNumber.foreground': CypherColor.white,
+    foreground: CypherColor.white
+  }
+}
+export const monacoLightTheme: monaco.editor.IStandaloneThemeData = {
+  base: 'vs',
+  inherit: false,
+  rules: lightThemeRules,
+  colors: {
+    'editor.background': base.preBackground,
+    'editorLineNumber.foreground': CypherColor.light_grey,
+    foreground: CypherColor.black
+  }
+}
diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index 1977a88af3b..13bfdb2209c 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -31,14 +31,14 @@ import {
   LIGHT_THEME,
   OUTLINE_THEME
 } from 'shared/modules/settings/settingsDuck'
+import {
+  BrowserTheme,
+  monacoDarkTheme,
+  monacoLightTheme
+} from './CypherMonacoThemes'
 import { CypherTokensProvider } from './CypherTokensProvider'
 import { shouldCheckForHints } from './Editor'
 
-type BrowserTheme =
-  | typeof LIGHT_THEME
-  | typeof OUTLINE_THEME
-  | typeof DARK_THEME
-
 interface MonacoProps {
   bus: Bus
   enableMultiStatementMode?: boolean
@@ -60,147 +60,14 @@ const Monaco = ({
   const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
   const monacoId = `monaco-${id}`
 
+  // Create monaco instance, listen to text changes and destroy
   useEffect(() => {
     monaco.languages.register({ id: 'cypher' })
     monaco.languages.setTokensProvider('cypher', new CypherTokensProvider())
 
-    // colors from cypher-editor/cypher-codemirror/src/css/_solarized.css
-    const enum Color {
-      blue = '#268bd2',
-      cyan = '#2aa198',
-      cyan_grey = '#586e75',
-      green = '#859900',
-      light_grey = '#93a1a1',
-      magenta = '#d33682',
-      orange = '#cb4b16',
-      red = '#dc322f',
-      violet = '#6c71c4',
-      yellow = '#b58900'
-    }
-
-    // syntax highlighting from cypher-editor/cypher-codemirror/src/css/syntax.css
-    const rules = [
-      // { token: 'p-label', foreGround: Color.orange },
-      // { token: 'p-relationshipType', foreGround: Color.orange },
-      // { token: 'p-variable', foreGround: Color.blue },
-      // { token: 'p-procedure', foreGround: Color.violet },
-      // { token: 'p-function', foreGround: Color.violet },
-      // {
-      //   token: 'p-parameter',
-      //   foreGround: Color.red
-      // },
-      // { token: 'p-property', foreGround: Color.cyan_grey },
-      // {
-      //   token: 's-cypher s-cypher-dark  p-property',
-      //   foreGround: Color.light_grey
-      // },
-      // { token: 'p-consoleCommand', foreGround: Color.magenta },
-      // { token: 'p-procedureOutput', foreGround: Color.blue },
-
-      ...[
-        'all',
-        'allshortestpaths',
-        'and',
-        'any',
-        'as',
-        'asc',
-        'ascending',
-        'assert',
-        'by',
-        'call',
-        'case',
-        'commit',
-        'constraint',
-        'contains',
-        'count',
-        'create',
-        'csv',
-        'cypher',
-        'delete',
-        'desc',
-        'descending',
-        'detach',
-        'distinct',
-        'drop',
-        'else',
-        'end',
-        'ends',
-        'enterrule',
-        'exists',
-        'exitrule',
-        'explain',
-        'extract',
-        'false',
-        'fieldterminator',
-        'filter',
-        'foreach',
-        'from',
-        'headers',
-        'in',
-        'index',
-        'is',
-        'join',
-        'key',
-        'l_skip',
-        'limit',
-        'load',
-        'match',
-        'merge',
-        'node',
-        'none',
-        'not',
-        'null',
-        'on',
-        'optional',
-        'or',
-        'order',
-        'periodic',
-        'profile',
-        'reduce',
-        'rel',
-        'relationship',
-        'remove',
-        'return',
-        'scan',
-        'set',
-        'shortestpath',
-        'single',
-        'start',
-        'starts',
-        'then',
-        'true',
-        'union',
-        'unique',
-        'unwind',
-        'using',
-        'when',
-        'where',
-        'with',
-        'xor',
-        'yield'
-      ].map((keyword: string) => ({
-        token: `${keyword}.cypher`,
-        foreground: Color.green
-      })),
-      ...['regulardecimalreal.cypher', 'decimalinteger.cypher'].map(token => ({
-        token,
-        foreground: Color.cyan
-      })),
-      { token: 'stringliteral.cypher', foreground: Color.yellow }
-    ]
-
-    monaco.editor.defineTheme(LIGHT_THEME, {
-      base: 'vs',
-      inherit: false,
-      rules: [...rules, { token: 'sp.cypher', foreground: Color.light_grey }],
-      colors: {}
-    })
-    monaco.editor.defineTheme(DARK_THEME, {
-      base: 'vs-dark',
-      inherit: false,
-      rules: [...rules, { token: 'sp.cypher', foreground: Color.cyan_grey }],
-      colors: {}
-    })
+    monaco.editor.defineTheme(DARK_THEME, monacoDarkTheme)
+    monaco.editor.defineTheme(LIGHT_THEME, monacoLightTheme)
+    monaco.editor.defineTheme(OUTLINE_THEME, monacoLightTheme)
 
     editorRef.current = monaco.editor.create(
       document.getElementById(monacoId) as HTMLElement,
@@ -208,9 +75,12 @@ const Monaco = ({
         automaticLayout: true,
         contextmenu: false,
         cursorStyle: 'block',
-        fontSize: 16,
+        fontFamily: 'Fira Code',
+        fontSize: 17,
+        fontWeight: '500',
         language: 'cypher',
         lightbulb: { enabled: false },
+        lineHeight: 23,
         links: false,
         minimap: { enabled: false },
         scrollBeyondLastColumn: 0,
@@ -230,14 +100,17 @@ const Monaco = ({
     }
   }, [])
 
+  // Update theme when setting is changed
   useEffect(() => {
     monaco.editor.setTheme(theme)
   }, [theme])
 
+  // Trigger update when multi statement setting is changed to update warnings
   useEffect(() => {
     onContentUpdate()
   }, [enableMultiStatementMode])
 
+  // Share current text with parent and add warnings
   const updateCode = () => {
     const text =
       editorRef.current
@@ -249,6 +122,9 @@ const Monaco = ({
     addWarnings(parse(text).referencesListener.queriesAndCommands)
   }
 
+  const debouncedUpdateCode = debounce(updateCode, 300)
+
+  // On each text change, clear warnings and reset countdown to adding warnings
   const onContentUpdate = () => {
     monaco.editor.setModelMarkers(
       editorRef.current?.getModel() as monaco.editor.ITextModel,
@@ -258,8 +134,6 @@ const Monaco = ({
     debouncedUpdateCode()
   }
 
-  const debouncedUpdateCode = debounce(updateCode, 300)
-
   const addWarnings = (
     statements: { start: { line: number }; getText: () => string }[]
   ) => {
diff --git a/src/browser/modules/Stream/EditFrame.tsx b/src/browser/modules/Stream/EditFrame.tsx
index 6cc53ee4bec..f9dd4b1ca77 100644
--- a/src/browser/modules/Stream/EditFrame.tsx
+++ b/src/browser/modules/Stream/EditFrame.tsx
@@ -23,25 +23,19 @@ import { connect } from 'react-redux'
 import { Action } from 'redux'
 import styled from 'styled-components'
 
+import { BrowserTheme } from '../Editor/CypherMonacoThemes'
 import Monaco from '../Editor/Monaco'
 import FrameTemplate from '../Frame/FrameTemplate'
 import { StyledFrameBody } from '../Frame/styled'
 import useDerivedTheme from 'browser-hooks/useDerivedTheme'
 import { executeCommand } from 'shared/modules/commands/commandsDuck'
 import {
-  DARK_THEME,
   getTheme,
   LIGHT_THEME,
-  OUTLINE_THEME,
   shouldEnableMultiStatementMode
 } from 'shared/modules/settings/settingsDuck'
 import { Frame, GlobalState } from 'shared/modules/stream/streamDuck'
 
-type BrowserTheme =
-  | typeof LIGHT_THEME
-  | typeof OUTLINE_THEME
-  | typeof DARK_THEME
-
 interface EditFrameProps {
   browserTheme: BrowserTheme
   enableMultiStatementMode: boolean
@@ -58,7 +52,7 @@ const ForceFullSizeFrameContent = styled.div`
 const EditFrame = (props: EditFrameProps): JSX.Element => {
   const [text, setText] = useState(props.frame.query)
 
-  const [derivedTheme] = useDerivedTheme(props.browserTheme, LIGHT_THEME) as [
+  const [theme] = useDerivedTheme(props.browserTheme, LIGHT_THEME) as [
     BrowserTheme
   ]
 
@@ -70,7 +64,7 @@ const EditFrame = (props: EditFrameProps): JSX.Element => {
             id={props.frame.id}
             enableMultiStatementMode={props.enableMultiStatementMode}
             onChange={setText}
-            theme={derivedTheme}
+            theme={theme}
             value={text}
           />
         }

From 48fbedffdba982170b6372a36983e8508329bb6a Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Mon, 12 Oct 2020 12:05:16 +0200
Subject: [PATCH 20/23] decrease monaco bundle size

---
 build_scripts/webpack-plugins.js              | 33 ++++++++++++++-
 build_scripts/webpack.config.js               | 27 +++++++++----
 .../modules/Editor/CypherMonacoThemes.ts      |  8 ++--
 .../modules/Editor/CypherTokensProvider.ts    |  8 ++--
 src/browser/modules/Editor/Monaco.tsx         | 40 ++++++++++---------
 5 files changed, 82 insertions(+), 34 deletions(-)

diff --git a/build_scripts/webpack-plugins.js b/build_scripts/webpack-plugins.js
index bb5dc0681c3..46ad952df3c 100644
--- a/build_scripts/webpack-plugins.js
+++ b/build_scripts/webpack-plugins.js
@@ -93,7 +93,38 @@ module.exports = () => {
       title: 'TypeScript',
       excludeWarnings: false
     }),
-    new MonacoWebpackPlugin()
+    new MonacoWebpackPlugin({
+      features: [
+        '!accessibilityHelp',
+        '!anchorSelect',
+        '!caretOperations',
+        '!clipboard',
+        '!codeAction',
+        '!codelens',
+        '!colorDetector',
+        '!contextmenu',
+        '!coreCommands',
+        '!cursorUndo',
+        '!dnd',
+        '!fontZoom',
+        '!gotoError',
+        '!gotoLine',
+        '!gotoSymbol',
+        '!iPadShowKeyboard',
+        '!inspectTokens',
+        '!links',
+        '!parameterHints',
+        '!quickHelp',
+        '!referenceSearch',
+        '!snippets',
+        '!toggleHighContrast',
+        '!toggleTabFocusMode',
+        '!transpose',
+        '!unusualLineTerminators',
+        '!viewportSemanticTokens'
+      ],
+      languages: []
+    })
   ]
 
   if (!helpers.isProduction) {
diff --git a/build_scripts/webpack.config.js b/build_scripts/webpack.config.js
index a31cb8ea8ec..edcc3caf514 100644
--- a/build_scripts/webpack.config.js
+++ b/build_scripts/webpack.config.js
@@ -62,19 +62,32 @@ module.exports = {
         splitChunks: {
           cacheGroups: {
             vendor: {
-              test: /[\\/]node_modules[\\/](react|react-dom|@firebase|d3|codemirror|faker|remark-mdx|@mdx-js)[\\/]/,
+              test: /[\\/]node_modules[\\/](react|react-dom|@firebase|d3)[\\/]/,
               name: 'vendor',
-              chunks: 'all'
+              chunks: 'all',
+              enforce: true
+            },
+            'cypher-editor': {
+              test: /[\\/]node_modules[\\/](antlr4|codemirror|cypher-codemirror|cypher-editor-support)[\\/]/,
+              name: 'cypher-editor',
+              chunks: 'all',
+              enforce: true
+            },
+            mdx: {
+              test: /[\\/]node_modules[\\/](@babel|@literal-jsx|@mdx-js|acorn|acorn-jsx|hast-util-raw|mdast-util-to-hast|remark-mdx|remark-parse)[\\/]/,
+              name: 'mdx',
+              chunks: 'all',
+              enforce: true
             },
-            'cypher-codemirror': {
-              test: /[\\/]node_modules[\\/](cypher-codemirror|cypher-editor-support)[\\/]/,
-              name: 'cypher-codemirror',
+            monaco: {
+              test: /[\\/]node_modules[\\/](monaco-editor)[\\/]/,
+              name: 'monaco',
               chunks: 'all',
               enforce: true
             },
-            ui: {
+            'relate-by-ui': {
               test: /[\\/]node_modules[\\/](@relate-by-ui|semantic-ui-react)[\\/]/,
-              name: 'ui',
+              name: 'relate-by-ui',
               chunks: 'all',
               enforce: true
             },
diff --git a/src/browser/modules/Editor/CypherMonacoThemes.ts b/src/browser/modules/Editor/CypherMonacoThemes.ts
index 525e3e438e0..4ca522bea1a 100644
--- a/src/browser/modules/Editor/CypherMonacoThemes.ts
+++ b/src/browser/modules/Editor/CypherMonacoThemes.ts
@@ -18,7 +18,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import * as monaco from 'monaco-editor'
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api'
 import { base } from 'browser-styles/themes'
 import {
   LIGHT_THEME,
@@ -224,7 +224,7 @@ const tokensWithoutSyntaxHighlighting: string[] = [
 ]
 
 // syntax highlighting from cypher-editor/cypher-codemirror/src/css/syntax.css
-const sharedRules: monaco.editor.ITokenThemeRule[] = [
+const sharedRules: editor.ITokenThemeRule[] = [
   ...strings.map(token => makeCypherTokenThemeRule(token, CypherColor.yellow)),
   ...numbers.map(token => makeCypherTokenThemeRule(token, CypherColor.cyan)),
 
@@ -279,7 +279,7 @@ const lightThemeRules = [
   )
 ]
 
-export const monacoDarkTheme: monaco.editor.IStandaloneThemeData = {
+export const monacoDarkTheme: editor.IStandaloneThemeData = {
   base: 'vs-dark',
   inherit: false,
   rules: darkThemeRules,
@@ -288,7 +288,7 @@ export const monacoDarkTheme: monaco.editor.IStandaloneThemeData = {
     foreground: CypherColor.white
   }
 }
-export const monacoLightTheme: monaco.editor.IStandaloneThemeData = {
+export const monacoLightTheme: editor.IStandaloneThemeData = {
   base: 'vs',
   inherit: false,
   rules: lightThemeRules,
diff --git a/src/browser/modules/Editor/CypherTokensProvider.ts b/src/browser/modules/Editor/CypherTokensProvider.ts
index bf0ee93f5cb..3cd7a4f7e1c 100644
--- a/src/browser/modules/Editor/CypherTokensProvider.ts
+++ b/src/browser/modules/Editor/CypherTokensProvider.ts
@@ -20,9 +20,9 @@
 
 import { InputStream } from 'antlr4/index.js'
 import { CypherLexer } from 'cypher-editor-support/src/_generated/CypherLexer'
-import * as monaco from 'monaco-editor'
+import { languages } from 'monaco-editor/esm/vs/editor/editor.api'
 
-class CypherState implements monaco.languages.IState {
+class CypherState implements languages.IState {
   clone() {
     return new CypherState()
   }
@@ -32,12 +32,12 @@ class CypherState implements monaco.languages.IState {
   }
 }
 
-export class CypherTokensProvider implements monaco.languages.TokensProvider {
+export class CypherTokensProvider implements languages.TokensProvider {
   getInitialState(): CypherState {
     return new CypherState()
   }
 
-  tokenize(line: string): monaco.languages.ILineTokens {
+  tokenize(line: string): languages.ILineTokens {
     const lexer = new CypherLexer(new InputStream(line))
 
     return {
diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index 13bfdb2209c..ef01cb6214a 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -20,7 +20,11 @@
 
 import { parse } from 'cypher-editor-support'
 import { debounce } from 'lodash-es'
-import * as monaco from 'monaco-editor'
+import {
+  editor,
+  languages,
+  MarkerSeverity
+} from 'monaco-editor/esm/vs/editor/editor.api'
 import React, { useEffect, useRef } from 'react'
 import { withBus } from 'react-suber'
 import { Bus } from 'suber'
@@ -45,7 +49,7 @@ interface MonacoProps {
   id: string
   value?: string
   onChange?: (value: string) => void
-  options?: monaco.editor.IGlobalEditorOptions
+  options?: editor.IGlobalEditorOptions
   theme?: BrowserTheme
 }
 
@@ -57,19 +61,19 @@ const Monaco = ({
   onChange = () => undefined,
   theme = LIGHT_THEME
 }: MonacoProps): JSX.Element => {
-  const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
+  const editorRef = useRef<editor.IStandaloneCodeEditor | null>(null)
   const monacoId = `monaco-${id}`
 
   // Create monaco instance, listen to text changes and destroy
   useEffect(() => {
-    monaco.languages.register({ id: 'cypher' })
-    monaco.languages.setTokensProvider('cypher', new CypherTokensProvider())
+    languages.register({ id: 'cypher' })
+    languages.setTokensProvider('cypher', new CypherTokensProvider())
 
-    monaco.editor.defineTheme(DARK_THEME, monacoDarkTheme)
-    monaco.editor.defineTheme(LIGHT_THEME, monacoLightTheme)
-    monaco.editor.defineTheme(OUTLINE_THEME, monacoLightTheme)
+    editor.defineTheme(DARK_THEME, monacoDarkTheme)
+    editor.defineTheme(LIGHT_THEME, monacoLightTheme)
+    editor.defineTheme(OUTLINE_THEME, monacoLightTheme)
 
-    editorRef.current = monaco.editor.create(
+    editorRef.current = editor.create(
       document.getElementById(monacoId) as HTMLElement,
       {
         automaticLayout: true,
@@ -102,7 +106,7 @@ const Monaco = ({
 
   // Update theme when setting is changed
   useEffect(() => {
-    monaco.editor.setTheme(theme)
+    editor.setTheme(theme)
   }, [theme])
 
   // Trigger update when multi statement setting is changed to update warnings
@@ -126,8 +130,8 @@ const Monaco = ({
 
   // On each text change, clear warnings and reset countdown to adding warnings
   const onContentUpdate = () => {
-    monaco.editor.setModelMarkers(
-      editorRef.current?.getModel() as monaco.editor.ITextModel,
+    editor.setModelMarkers(
+      editorRef.current?.getModel() as editor.ITextModel,
       monacoId,
       []
     )
@@ -139,12 +143,12 @@ const Monaco = ({
   ) => {
     if (!statements.length) return
 
-    const model = editorRef.current?.getModel() as monaco.editor.ITextModel
+    const model = editorRef.current?.getModel() as editor.ITextModel
 
     // add multi statement warning if multi setting is off
     if (statements.length > 1 && !enableMultiStatementMode) {
       const secondStatementLine = statements[1].start.line
-      monaco.editor.setModelMarkers(model, monacoId, [
+      editor.setModelMarkers(model, monacoId, [
         {
           startLineNumber: secondStatementLine,
           startColumn: 1,
@@ -152,7 +156,7 @@ const Monaco = ({
           endColumn: 1000,
           message:
             'To use multi statement queries, please enable multi statement in the settings panel.',
-          severity: monaco.MarkerSeverity.Warning
+          severity: MarkerSeverity.Warning
         }
       ])
     }
@@ -176,8 +180,8 @@ const Monaco = ({
             response.success === true &&
             response.result.summary.notifications.length > 0
           ) {
-            monaco.editor.setModelMarkers(model, monacoId, [
-              ...monaco.editor.getModelMarkers({ owner: monacoId }),
+            editor.setModelMarkers(model, monacoId, [
+              ...editor.getModelMarkers({ owner: monacoId }),
               ...response.result.summary.notifications.map(
                 ({
                   description,
@@ -193,7 +197,7 @@ const Monaco = ({
                   endLineNumber: statementLineNumber + line,
                   endColumn: 1000,
                   message: title + '\n\n' + description,
-                  severity: monaco.MarkerSeverity.Warning
+                  severity: MarkerSeverity.Warning
                 })
               )
             ])

From 968eb15a11b01a0b2dc293d95958d31584e2ddda Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Tue, 13 Oct 2020 18:48:31 +0200
Subject: [PATCH 21/23] add tests for monaco editor

---
 package.json                                  |  3 +-
 .../Editor/CypherTokensProvider.test.ts       | 37 ++++++++
 src/browser/modules/Editor/Monaco.test.tsx    | 35 +++++++
 src/browser/modules/Stream/EditFrame.test.tsx | 40 ++++++++
 src/shared/services/bolt/boltConnection.js    |  2 +-
 .../services/bolt/boltConnection.test.ts      | 36 +++++++
 yarn.lock                                     | 95 ++++++-------------
 7 files changed, 179 insertions(+), 69 deletions(-)
 create mode 100644 src/browser/modules/Editor/CypherTokensProvider.test.ts
 create mode 100644 src/browser/modules/Editor/Monaco.test.tsx
 create mode 100644 src/browser/modules/Stream/EditFrame.test.tsx
 create mode 100644 src/shared/services/bolt/boltConnection.test.ts

diff --git a/package.json b/package.json
index 509bbfa044c..e076762a147 100644
--- a/package.json
+++ b/package.json
@@ -67,7 +67,7 @@
     "@hot-loader/react-dom": "^16.8.6",
     "@pmmmwh/react-refresh-webpack-plugin": "^0.4.1",
     "@testing-library/jest-dom": "^5.3.0",
-    "@testing-library/react": "^9.0.1",
+    "@testing-library/react": "^10.4.9",
     "@testing-library/react-hooks": "^2.0.1",
     "@types/antlr4": "^4.7.2",
     "@types/apollo-upload-client": "^14.1.0",
@@ -76,6 +76,7 @@
     "@types/react": "^16.9.23",
     "@types/react-dom": "^16.9.8",
     "@types/react-redux": "^7.1.9",
+    "@types/redux-mock-store": "^1.0.2",
     "@types/styled-components": "^5.1.1",
     "@types/uuid": "^8.3.0",
     "@typescript-eslint/eslint-plugin": "^3.9.0",
diff --git a/src/browser/modules/Editor/CypherTokensProvider.test.ts b/src/browser/modules/Editor/CypherTokensProvider.test.ts
new file mode 100644
index 00000000000..ec70b552ee1
--- /dev/null
+++ b/src/browser/modules/Editor/CypherTokensProvider.test.ts
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { CypherTokensProvider } from './CypherTokensProvider'
+
+describe('CypherTokensProvider', () => {
+  it('takes a line of cypher and returns a set of tokens', () => {
+    const cypher = 'RETURN 1'
+
+    const expectedTokens = [
+      { scopes: 'return.cypher', startIndex: 0 },
+      { scopes: 'sp.cypher', startIndex: 6 },
+      { scopes: 'decimalinteger.cypher', startIndex: 7 }
+    ]
+
+    const actualTokens = new CypherTokensProvider().tokenize(cypher).tokens
+
+    expect(actualTokens).toEqual(expectedTokens)
+  })
+})
diff --git a/src/browser/modules/Editor/Monaco.test.tsx b/src/browser/modules/Editor/Monaco.test.tsx
new file mode 100644
index 00000000000..eb165389779
--- /dev/null
+++ b/src/browser/modules/Editor/Monaco.test.tsx
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import React from 'react'
+import { fireEvent, render } from '@testing-library/react'
+
+import Monaco from './Monaco'
+
+describe('Monaco', () => {
+  it('renders a component that functions as a textbox', () => {
+    const { getByRole, queryByDisplayValue } = render(<Monaco />)
+
+    const value = 'hello world'
+    fireEvent.input(getByRole('textbox'), { target: { value } })
+
+    expect(queryByDisplayValue(value)).toBeDefined()
+  })
+})
diff --git a/src/browser/modules/Stream/EditFrame.test.tsx b/src/browser/modules/Stream/EditFrame.test.tsx
new file mode 100644
index 00000000000..873e1fd5937
--- /dev/null
+++ b/src/browser/modules/Stream/EditFrame.test.tsx
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import React from 'react'
+import { render } from '@testing-library/react'
+import { Provider } from 'react-redux'
+import configureStore from 'redux-mock-store'
+
+import EditFrame from './EditFrame'
+import { Frame } from 'shared/modules/stream/streamDuck'
+
+describe('EditFrame', () => {
+  it('creates a monaco instance with a unique id based on frame id', () => {
+    const id = 'some-frame-id'
+    const frame = { id } as Frame
+    const { container } = render(
+      <Provider store={configureStore()({ settings: {} })}>
+        <EditFrame frame={frame} />
+      </Provider>
+    )
+    expect(container.querySelector(`#monaco-${id}`)).toBeDefined()
+  })
+})
diff --git a/src/shared/services/bolt/boltConnection.js b/src/shared/services/bolt/boltConnection.js
index 933fc0ca1dc..cd23040555c 100644
--- a/src/shared/services/bolt/boltConnection.js
+++ b/src/shared/services/bolt/boltConnection.js
@@ -45,7 +45,7 @@ export const hasMultiDbSupport = async () => {
   return supportsMultiDb
 }
 
-const validateConnection = (driver, res, rej) => {
+export const validateConnection = (driver, res, rej) => {
   if (driver === null) {
     rej()
     return
diff --git a/src/shared/services/bolt/boltConnection.test.ts b/src/shared/services/bolt/boltConnection.test.ts
new file mode 100644
index 00000000000..705464d2b5c
--- /dev/null
+++ b/src/shared/services/bolt/boltConnection.test.ts
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2002-2020 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { validateConnection } from './boltConnection'
+
+describe('validateConnection', () => {
+  it('should reject if driver is `null`', () => {
+    // validate can be called before driver is in store, which used to result in a `TypeError: Cannot read property 'supportsMultiDb' of null` error,
+    // reject if driver is null is a fix to not have that error in console
+    const driver = null
+    const resolve = jest.fn()
+    const reject = jest.fn()
+
+    validateConnection(driver, resolve, reject)
+
+    expect(resolve).not.toHaveBeenCalled()
+    expect(reject).toHaveBeenCalled()
+  })
+})
diff --git a/yarn.lock b/yarn.lock
index e8fa3e6ba66..213a6a75763 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1860,11 +1860,6 @@
     exenv "^1.2.2"
     prop-types "^15.6.2"
 
-"@sheerun/mutationobserver-shim@^0.3.2":
-  version "0.3.3"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/@sheerun/mutationobserver-shim/-/mutationobserver-shim-0.3.3.tgz#5405ee8e444ed212db44e79351f0c70a582aae25"
-  integrity sha1-VAXujkRO0hLbROeTUfDHClgqriU=
-
 "@sinonjs/commons@^1.7.0":
   version "1.8.1"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@sinonjs/commons/-/commons-1.8.1.tgz#e7df00f98a203324f6dc7cc606cad9d4a8ab2217"
@@ -1889,10 +1884,10 @@
     prop-types "^15.7.2"
     react-is "^16.6.3"
 
-"@testing-library/dom@*":
-  version "7.24.2"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/@testing-library/dom/-/dom-7.24.2.tgz#6d2b7dd21efbd5358b98c2777fc47c252f3ae55e"
-  integrity sha1-bSt90h771TWLmMJ3f8R8JS865V4=
+"@testing-library/dom@^7.22.3":
+  version "7.26.0"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/@testing-library/dom/-/dom-7.26.0.tgz#da4d052dc426a4ccc916303369c6e7552126f680"
+  integrity sha1-2k0FLcQmpMzJFjAzacbnVSEm9oA=
   dependencies:
     "@babel/code-frame" "^7.10.4"
     "@babel/runtime" "^7.10.3"
@@ -1900,21 +1895,9 @@
     aria-query "^4.2.2"
     chalk "^4.1.0"
     dom-accessibility-api "^0.5.1"
+    lz-string "^1.4.4"
     pretty-format "^26.4.2"
 
-"@testing-library/dom@^6.15.0":
-  version "6.16.0"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/@testing-library/dom/-/dom-6.16.0.tgz#04ada27ed74ad4c0f0d984a1245bb29b1fd90ba9"
-  integrity sha1-BK2iftdK1MDw2YShJFuymx/ZC6k=
-  dependencies:
-    "@babel/runtime" "^7.8.4"
-    "@sheerun/mutationobserver-shim" "^0.3.2"
-    "@types/testing-library__dom" "^6.12.1"
-    aria-query "^4.0.2"
-    dom-accessibility-api "^0.3.0"
-    pretty-format "^25.1.0"
-    wait-for-expect "^3.0.2"
-
 "@testing-library/jest-dom@^5.3.0":
   version "5.11.4"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@testing-library/jest-dom/-/jest-dom-5.11.4.tgz#f325c600db352afb92995c2576022b35621ddc99"
@@ -1937,14 +1920,13 @@
     "@babel/runtime" "^7.5.4"
     "@types/testing-library__react-hooks" "^2.0.0"
 
-"@testing-library/react@^9.0.1":
-  version "9.5.0"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/@testing-library/react/-/react-9.5.0.tgz#71531655a7890b61e77a1b39452fbedf0472ca5e"
-  integrity sha1-cVMWVaeJC2Hnehs5RS++3wRyyl4=
+"@testing-library/react@^10.4.9":
+  version "10.4.9"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/@testing-library/react/-/react-10.4.9.tgz#9faa29c6a1a217bf8bbb96a28bd29d7a847ca150"
+  integrity sha1-n6opxqGiF7+Lu5aii9KdeoR8oVA=
   dependencies:
-    "@babel/runtime" "^7.8.4"
-    "@testing-library/dom" "^6.15.0"
-    "@types/testing-library__react" "^9.1.2"
+    "@babel/runtime" "^7.10.3"
+    "@testing-library/dom" "^7.22.3"
 
 "@types/antlr4@^4.7.2":
   version "4.7.2"
@@ -2179,7 +2161,7 @@
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/prop-types/-/prop-types-15.7.3.tgz#2ab0d5da2e5815f94b0b9d4b95d1e5f243ab2ca7"
   integrity sha1-KrDV2i5YFflLC51LldHl8kOrLKc=
 
-"@types/react-dom@*", "@types/react-dom@^16.9.8":
+"@types/react-dom@^16.9.8":
   version "16.9.8"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/react-dom/-/react-dom-16.9.8.tgz#fe4c1e11dfc67155733dfa6aa65108b4971cb423"
   integrity sha1-/kweEd/GcVVzPfpqplEItJcctCM=
@@ -2218,6 +2200,13 @@
     "@types/prop-types" "*"
     csstype "^3.0.2"
 
+"@types/redux-mock-store@^1.0.2":
+  version "1.0.2"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/redux-mock-store/-/redux-mock-store-1.0.2.tgz#c27d5deadfb29d8514bdb0fc2cadae6feea1922d"
+  integrity sha1-wn1d6t+ynYUUvbD8LK2ub+6hki0=
+  dependencies:
+    redux "^4.0.5"
+
 "@types/shallowequal@^1.1.1":
   version "1.1.1"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/shallowequal/-/shallowequal-1.1.1.tgz#aad262bb3f2b1257d94c71d545268d592575c9b1"
@@ -2258,20 +2247,6 @@
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/tapable/-/tapable-1.0.6.tgz#a9ca4b70a18b270ccb2bc0aaafefd1d486b7ea74"
   integrity sha1-qcpLcKGLJwzLK8Cqr+/R1Ia36nQ=
 
-"@types/testing-library__dom@*":
-  version "7.5.0"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/testing-library__dom/-/testing-library__dom-7.5.0.tgz#e0a00dd766983b1d6e9d10d33e708005ce6ad13e"
-  integrity sha1-4KAN12aYOx1unRDTPnCABc5q0T4=
-  dependencies:
-    "@testing-library/dom" "*"
-
-"@types/testing-library__dom@^6.12.1":
-  version "6.14.0"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/testing-library__dom/-/testing-library__dom-6.14.0.tgz#1aede831cb4ed4a398448df5a2c54b54a365644e"
-  integrity sha1-Gu3oMctO1KOYRI31osVLVKNlZE4=
-  dependencies:
-    pretty-format "^24.3.0"
-
 "@types/testing-library__jest-dom@^5.9.1":
   version "5.9.2"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/testing-library__jest-dom/-/testing-library__jest-dom-5.9.2.tgz#59e4771a1cf87d51e89a5cc8195cd3b647cba322"
@@ -2287,15 +2262,6 @@
     "@types/react" "*"
     "@types/react-test-renderer" "*"
 
-"@types/testing-library__react@^9.1.2":
-  version "9.1.3"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/testing-library__react/-/testing-library__react-9.1.3.tgz#35eca61cc6ea923543796f16034882a1603d7302"
-  integrity sha1-NeymHMbqkjVDeW8WA0iCoWA9cwI=
-  dependencies:
-    "@types/react-dom" "*"
-    "@types/testing-library__dom" "*"
-    pretty-format "^25.1.0"
-
 "@types/uglify-js@*":
   version "3.9.3"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/@types/uglify-js/-/uglify-js-3.9.3.tgz#d94ed608e295bc5424c9600e6b8565407b6b4b6b"
@@ -2875,7 +2841,7 @@ argparse@^1.0.7:
   dependencies:
     sprintf-js "~1.0.2"
 
-aria-query@^4.0.2, aria-query@^4.2.2:
+aria-query@^4.2.2:
   version "4.2.2"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/aria-query/-/aria-query-4.2.2.tgz#0d2ca6c9aceb56b8977e9fed6aed7e15bbd2f83b"
   integrity sha1-DSymyazrVriXfp/tau1+FbvS+Ds=
@@ -4930,11 +4896,6 @@ doctrine@^3.0.0:
   dependencies:
     esutils "^2.0.2"
 
-dom-accessibility-api@^0.3.0:
-  version "0.3.0"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/dom-accessibility-api/-/dom-accessibility-api-0.3.0.tgz#511e5993dd673b97c87ea47dba0e3892f7e0c983"
-  integrity sha1-UR5Zk91nO5fIfqR9ug44kvfgyYM=
-
 dom-accessibility-api@^0.5.1:
   version "0.5.2"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/dom-accessibility-api/-/dom-accessibility-api-0.5.2.tgz#ef3cdb5d3f0d599d8f9c8b18df2fb63c9793739d"
@@ -8615,6 +8576,11 @@ lru-cache@^6.0.0:
   dependencies:
     yallist "^4.0.0"
 
+lz-string@^1.4.4:
+  version "1.4.4"
+  resolved "https://neo.jfrog.io/neo/api/npm/npm/lz-string/-/lz-string-1.4.4.tgz#c0d8eaf36059f705796e1e344811cf4c498d3a26"
+  integrity sha1-wNjq82BZ9wV5bh40SBHPTEmNOiY=
+
 magic-string@^0.25.3:
   version "0.25.7"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/magic-string/-/magic-string-0.25.7.tgz#3f497d6fd34c669c6798dcb821f2ef31f5445051"
@@ -10485,7 +10451,7 @@ pretty-format@^23.0.1:
     ansi-regex "^3.0.0"
     ansi-styles "^3.2.0"
 
-pretty-format@^24.3.0, pretty-format@^24.9.0:
+pretty-format@^24.9.0:
   version "24.9.0"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/pretty-format/-/pretty-format-24.9.0.tgz#12fac31b37019a4eea3c11aa9a959eb7628aa7c9"
   integrity sha1-EvrDGzcBmk7qPBGqmpWet2KKp8k=
@@ -10495,7 +10461,7 @@ pretty-format@^24.3.0, pretty-format@^24.9.0:
     ansi-styles "^3.2.0"
     react-is "^16.8.4"
 
-pretty-format@^25.1.0, pretty-format@^25.2.1, pretty-format@^25.5.0:
+pretty-format@^25.2.1, pretty-format@^25.5.0:
   version "25.5.0"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/pretty-format/-/pretty-format-25.5.0.tgz#7873c1d774f682c34b8d48b6743a2bf2ac55791a"
   integrity sha1-eHPB13T2gsNLjUi2dDor8qxVeRo=
@@ -11052,7 +11018,7 @@ redux@^3.7.2:
     loose-envify "^1.1.0"
     symbol-observable "^1.0.3"
 
-redux@^4.0.0, redux@^4.0.4:
+redux@^4.0.0, redux@^4.0.4, redux@^4.0.5:
   version "4.0.5"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/redux/-/redux-4.0.5.tgz#4db5de5816e17891de8a80c424232d06f051d93f"
   integrity sha1-TbXeWBbheJHeioDEJCMtBvBR2T8=
@@ -13119,11 +13085,6 @@ w3c-xmlserializer@^1.1.2:
     webidl-conversions "^4.0.2"
     xml-name-validator "^3.0.0"
 
-wait-for-expect@^3.0.2:
-  version "3.0.2"
-  resolved "https://neo.jfrog.io/neo/api/npm/npm/wait-for-expect/-/wait-for-expect-3.0.2.tgz#d2f14b2f7b778c9b82144109c8fa89ceaadaa463"
-  integrity sha1-0vFLL3t3jJuCFEEJyPqJzqrapGM=
-
 wait-on@^3.1.0:
   version "3.3.0"
   resolved "https://neo.jfrog.io/neo/api/npm/npm/wait-on/-/wait-on-3.3.0.tgz#9940981d047a72a9544a97b8b5fca45b2170a082"

From 6e3491969fb4b24da75cf074efc657eb7413ec8d Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Tue, 13 Oct 2020 19:29:32 +0200
Subject: [PATCH 22/23] fix issue with incorrect multi-statement warning when
 repeatedly clicking setting on and off

---
 src/browser/modules/Editor/Monaco.tsx | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index ef01cb6214a..c3170ef4c03 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -145,6 +145,13 @@ const Monaco = ({
 
     const model = editorRef.current?.getModel() as editor.ITextModel
 
+    // clearing markers again solves issue with incorrect multi-statement warning when user spam clicks setting on and off
+    editor.setModelMarkers(
+      editorRef.current?.getModel() as editor.ITextModel,
+      monacoId,
+      []
+    )
+
     // add multi statement warning if multi setting is off
     if (statements.length > 1 && !enableMultiStatementMode) {
       const secondStatementLine = statements[1].start.line

From 8fcadcfc640a313bfb360b3b8e0c9e56ac297986 Mon Sep 17 00:00:00 2001
From: Emil Andersson <emil.andersson@neotechnology.com>
Date: Tue, 13 Oct 2020 19:41:09 +0200
Subject: [PATCH 23/23] use the correct monaco theme when OS theme is light and
 browser theme is auto

---
 src/browser/modules/Editor/Monaco.tsx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/browser/modules/Editor/Monaco.tsx b/src/browser/modules/Editor/Monaco.tsx
index c3170ef4c03..dabebed2ee7 100644
--- a/src/browser/modules/Editor/Monaco.tsx
+++ b/src/browser/modules/Editor/Monaco.tsx
@@ -72,6 +72,9 @@ const Monaco = ({
     editor.defineTheme(DARK_THEME, monacoDarkTheme)
     editor.defineTheme(LIGHT_THEME, monacoLightTheme)
     editor.defineTheme(OUTLINE_THEME, monacoLightTheme)
+    // Browser's light theme is called 'normal', but OS's light theme is called 'light'
+    // 'light' is used when theme is set to light in OS and auto in browser
+    editor.defineTheme('light', monacoLightTheme)
 
     editorRef.current = editor.create(
       document.getElementById(monacoId) as HTMLElement,