From 00d818c762bf0f2dd45ae1eb65ce3d0f1c717081 Mon Sep 17 00:00:00 2001
From: Mislav Bradac <mislav.bradac@memgraph.io>
Date: Wed, 8 Mar 2017 14:09:25 +0100
Subject: [PATCH] Implement expression code generator
Summary: Work in progress, this is not usable yet
Reviewers: florijan
Reviewed By: florijan
Subscribers: pullbot
Differential Revision: https://phabricator.memgraph.io/D84
---
src/query/backend/cpp/code_generator.cpp | 29 +
src/query/backend/cpp/code_generator.hpp | 15 +
src/query/backend/cpp/compiler_structures.hpp | 51 +-
src/query/backend/cpp/cypher_main_visitor.cpp | 432 +-
src/query/backend/cpp/cypher_main_visitor.hpp | 300 +-
src/query/backend/cpp/named_antlr_tokens.hpp | 24 +
src/query/backend/cpp/runtime_functions.cpp | 20 +
src/query/backend/cpp/runtime_functions.hpp | 10 +
src/query/backend/cpp/typed_value.cpp | 142 +-
src/query/backend/cpp/typed_value.hpp | 5 +
.../opencypher/generated/Cypher.tokens | 213 +-
.../generated/CypherBaseListener.cpp | 7 +-
.../opencypher/generated/CypherBaseListener.h | 5 +-
.../generated/CypherBaseVisitor.cpp | 7 +-
.../opencypher/generated/CypherBaseVisitor.h | 6 +-
.../opencypher/generated/CypherLexer.cpp | 2185 +--
.../opencypher/generated/CypherLexer.h | 29 +-
.../opencypher/generated/CypherLexer.tokens | 213 +-
.../opencypher/generated/CypherListener.cpp | 7 +-
.../opencypher/generated/CypherListener.h | 5 +-
.../opencypher/generated/CypherParser.cpp | 12965 ++++++++--------
.../opencypher/generated/CypherParser.h | 73 +-
.../opencypher/generated/CypherVisitor.cpp | 7 +-
.../opencypher/generated/CypherVisitor.h | 4 +-
.../frontend/opencypher/grammar/Cypher.g4 | 31 +-
src/storage/property_value.cpp | 25 +-
tests/manual/antlr_tree_pretty_print.cpp | 62 +
tests/unit/cypher_main_visitor.cpp | 57 +-
tests/unit/typed_value.cpp | 11 +-
29 files changed, 8604 insertions(+), 8336 deletions(-)
create mode 100644 src/query/backend/cpp/code_generator.cpp
create mode 100644 src/query/backend/cpp/code_generator.hpp
create mode 100644 src/query/backend/cpp/named_antlr_tokens.hpp
create mode 100644 src/query/backend/cpp/runtime_functions.cpp
create mode 100644 src/query/backend/cpp/runtime_functions.hpp
create mode 100644 tests/manual/antlr_tree_pretty_print.cpp
diff --git a/src/query/backend/cpp/code_generator.cpp b/src/query/backend/cpp/code_generator.cpp
new file mode 100644
index 000000000..fc040094d
--- /dev/null
+++ b/src/query/backend/cpp/code_generator.cpp
@@ -0,0 +1,29 @@
+#include "query/backend/cpp/code_generator.hpp"
+
+#include <string>
+#include <vector>
+
+#include "query/backend/cpp/named_antlr_tokens.hpp"
+#include "utils/assert.hpp"
+
+namespace {
+std::string kLogicalOr = "||";
+// OpenCypher supports xor operator only for booleans, so we can use binary xor
+// instead.
+std::string kLogicalXor = "^";
+std::string kLogicalAnd = "&&";
+std::string kLogicalNot = "!";
+std::string kEq = "=";
+std::string kNe = "!=";
+std::string kLt = "<";
+std::string kGt = ">";
+std::string kLe = "<=";
+std::string kGe = ">=";
+std::string kPlus = "+";
+std::string kMinus = "-";
+std::string kMult = "*";
+std::string kDiv = "/";
+std::string kMod = "%";
+std::string kUnaryMinus = "-";
+std::string kUnaryPlus = ""; // No need to generate anything.
+}
diff --git a/src/query/backend/cpp/code_generator.hpp b/src/query/backend/cpp/code_generator.hpp
new file mode 100644
index 000000000..78d11f77c
--- /dev/null
+++ b/src/query/backend/cpp/code_generator.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "query/frontend/opencypher/generated/CypherBaseVisitor.h"
+#include "antlr4-runtime.h"
+
+using antlropencypher::CypherParser;
+
+class CodeGenerator {
+ void GenerateExpresssion();
+
+ private:
+ std::string code_;
+};
diff --git a/src/query/backend/cpp/compiler_structures.hpp b/src/query/backend/cpp/compiler_structures.hpp
index 1c14d80a4..4c62b1d79 100644
--- a/src/query/backend/cpp/compiler_structures.hpp
+++ b/src/query/backend/cpp/compiler_structures.hpp
@@ -5,6 +5,9 @@
#include "query/frontend/opencypher/generated/CypherParser.h"
#include "utils/exceptions/basic_exception.hpp"
+namespace backend {
+namespace cpp {
+
// TODO: Figure out what information to put in exception.
// Error reporting is tricky since we get stripped query and position of error
// in original query is not same as position of error in stripped query. Most
@@ -22,21 +25,17 @@ class SemanticException : BasicException {
// enum VariableType { TYPED_VALUE, LIST, MAP, NODE, RELATIONSHIP, PATH };
struct Node {
- std::string output_identifier;
+ std::string output_id;
std::vector<std::string> labels;
- std::unordered_map<std::string,
- antlropencypher::CypherParser::ExpressionContext*>
- properties;
+ std::unordered_map<std::string, std::string> properties;
};
struct Relationship {
enum Direction { LEFT, RIGHT, BOTH };
- std::string output_identifier;
+ std::string output_id;
Direction direction = Direction::BOTH;
std::vector<std::string> types;
- std::unordered_map<std::string,
- antlropencypher::CypherParser::ExpressionContext*>
- properties;
+ std::unordered_map<std::string, std::string> properties;
bool has_range = false;
// If has_range is false, lower and upper bound values are not important.
// lower_bound can be larger than upper_bound and in that case there is no
@@ -46,7 +45,37 @@ struct Relationship {
};
struct PatternPart {
- std::string output_identifier;
- std::vector<Node> nodes;
- std::vector<Relationship> relationships;
+ std::string output_id;
+ std::vector<std::string> nodes;
+ std::vector<std::string> relationships;
};
+
+enum class Function {
+ LOGICAL_OR,
+ LOGICAL_XOR,
+ LOGICAL_AND,
+ LOGICAL_NOT,
+ EQ,
+ NE,
+ LT,
+ GT,
+ LE,
+ GE,
+ ADDITION,
+ SUBTRACTION,
+ MULTIPLICATION,
+ DIVISION,
+ MODULO,
+ UNARY_MINUS,
+ UNARY_PLUS,
+ PROPERTY_GETTER,
+ LITERAL,
+ PARAMETER
+};
+
+struct SimpleExpression {
+ Function function;
+ std::vector<std::string> arguments;
+};
+}
+}
diff --git a/src/query/backend/cpp/cypher_main_visitor.cpp b/src/query/backend/cpp/cypher_main_visitor.cpp
index 6fe2d205b..368785014 100644
--- a/src/query/backend/cpp/cypher_main_visitor.cpp
+++ b/src/query/backend/cpp/cypher_main_visitor.cpp
@@ -7,36 +7,79 @@
#include <vector>
#include "query/backend/cpp/compiler_structures.hpp"
+#include "query/backend/cpp/named_antlr_tokens.hpp"
#include "utils/assert.hpp"
+namespace backend {
+namespace cpp {
+
namespace {
-// List of unnamed tokens visitor needs to use. This should be reviewed on every
-// grammar change since even changes in ordering of rules will cause antlr to
-// generate different constants for unnamed tokens.
-const auto kDotsTokenId = CypherParser::T__12; // ..
+// Map children tokens of antlr node to Function enum.
+std::vector<Function> MapTokensToOperators(
+ antlr4::ParserRuleContext *node,
+ const std::unordered_map<size_t, Function> token_to_operator) {
+ std::vector<antlr4::tree::TerminalNode *> tokens;
+ for (const auto &x : token_to_operator) {
+ tokens.insert(tokens.end(), node->getTokens(x.first).begin(),
+ node->getTokens(x.first).end());
+ }
+ sort(tokens.begin(), tokens.end(), [](antlr4::tree::TerminalNode *a,
+ antlr4::tree::TerminalNode *b) {
+ return a->getSourceInterval().startsBeforeDisjoint(b->getSourceInterval());
+ });
+ std::vector<Function> ops;
+ for (auto *token : tokens) {
+ auto it = token_to_operator.find(token->getSymbol()->getType());
+ debug_assert(it != token_to_operator.end(),
+ "Wrong mapping sent to function.");
+ ops.push_back(it->second);
+ }
+ return ops;
+}
}
antlrcpp::Any CypherMainVisitor::visitNodePattern(
CypherParser::NodePatternContext *ctx) {
+ bool new_node = true;
Node node;
- node.output_identifier = new_identifier();
if (ctx->variable()) {
- identifiers_map_[ctx->variable()->accept(this).as<std::string>()] =
- node.output_identifier;
+ auto variable = ctx->variable()->accept(this).as<std::string>();
+ auto &curr_id_map = ids_map_.back();
+ if (curr_id_map.find(variable) != curr_id_map.end()) {
+ if (!symbol_table_[curr_id_map[variable]].is<Node>()) {
+ throw SemanticException();
+ }
+ new_node = false;
+ node = symbol_table_[curr_id_map[variable]].as<Node>();
+ } else {
+ node.output_id = new_id();
+ curr_id_map[variable] = node.output_id;
+ }
+ } else {
+ node.output_id = new_id();
+ }
+ if (!new_node && (ctx->nodeLabels() || ctx->properties())) {
+ // If variable is already declared, we cannot list properties or labels.
+ // This is slightly incompatible with neo4j. In neo4j it is valid to write
+ // MATCH (n {a: 5})--(n {b: 10}) which is equivalent to MATCH(n {a:5, b:
+ // 10})--(n). Neo4j also allows MATCH (n) RETURN (n {x: 5}) which is
+ // equivalent to MATCH (n) RETURN ({x: 5}).
+ // TODO: The way in which we are storing nodes is not suitable for optional
+ // match. For example: MATCH (n {a: 5}) OPTIONAL MATCH (n {b: 10}) RETURN
+ // n.a, n.b. would not work. Think more about that case.
+ throw SemanticException();
}
if (ctx->nodeLabels()) {
node.labels =
ctx->nodeLabels()->accept(this).as<std::vector<std::string>>();
}
if (ctx->properties()) {
- node.properties =
- ctx->properties()
- ->accept(this)
- .as<std::unordered_map<std::string,
- CypherParser::ExpressionContext *>>();
+ node.properties = ctx->properties()
+ ->accept(this)
+ .as<std::unordered_map<std::string, std::string>>();
}
- symbol_table_[node.output_identifier] = node;
- return node;
+ symbol_table_[node.output_id] = node;
+ return node.output_id;
}
antlrcpp::Any CypherMainVisitor::visitNodeLabels(
@@ -60,32 +103,30 @@ antlrcpp::Any CypherMainVisitor::visitProperties(
antlrcpp::Any CypherMainVisitor::visitMapLiteral(
CypherParser::MapLiteralContext *ctx) {
- std::unordered_map<std::string, CypherParser::ExpressionContext *> map;
+ std::unordered_map<std::string, std::string> map;
for (int i = 0; i < (int)ctx->propertyKeyName().size(); ++i) {
map[ctx->propertyKeyName()[i]->accept(this).as<std::string>()] =
- ctx->expression()[i];
+ ctx->expression()[i]->accept(this).as<std::string>();
}
return map;
}
antlrcpp::Any CypherMainVisitor::visitSymbolicName(
CypherParser::SymbolicNameContext *ctx) {
- if (!ctx->UnescapedSymbolicName()) {
- // SymbolicName can only be UnescapedSymbolicName. At this moment we want to
- // avoid openCypher crazyness that allows variables to be named as keywords
- // and escaped sequences. To allow all possible variable names allowed by
- // openCypher grammar we need to figure out escaping rules so we can
- // reference same variable as unescaped and escaped string.
+ if (ctx->EscapedSymbolicName()) {
+ // We don't allow at this point for variable to be EscapedSymbolicName
+ // because we would have t ofigure out how escaping works since same
+ // variable can be referenced in two ways: escaped and unescaped.
throw SemanticException();
}
- return ctx->getText();
+ return std::string(ctx->getText());
}
antlrcpp::Any CypherMainVisitor::visitPattern(
CypherParser::PatternContext *ctx) {
- std::vector<PatternPart> pattern;
+ std::vector<std::string> pattern;
for (auto *pattern_part : ctx->patternPart()) {
- pattern.push_back(pattern_part->accept(this).as<PatternPart>());
+ pattern.push_back(pattern_part->accept(this).as<std::string>());
}
return pattern;
}
@@ -95,11 +136,15 @@ antlrcpp::Any CypherMainVisitor::visitPatternPart(
PatternPart pattern_part =
ctx->anonymousPatternPart()->accept(this).as<PatternPart>();
if (ctx->variable()) {
- identifiers_map_[ctx->variable()->accept(this).as<std::string>()] =
- pattern_part.output_identifier;
+ std::string variable = ctx->variable()->accept(this).as<std::string>();
+ auto &curr_id_map = ids_map_.back();
+ if (curr_id_map.find(variable) != curr_id_map.end()) {
+ throw SemanticException();
+ }
+ curr_id_map[variable] = pattern_part.output_id;
}
- symbol_table_[pattern_part.output_identifier] = pattern_part;
- return pattern_part;
+ symbol_table_[pattern_part.output_id] = pattern_part;
+ return pattern_part.output_id;
}
antlrcpp::Any CypherMainVisitor::visitPatternElement(
@@ -108,11 +153,12 @@ antlrcpp::Any CypherMainVisitor::visitPatternElement(
return ctx->patternElement()->accept(this);
}
PatternPart pattern_part;
- pattern_part.output_identifier = new_identifier();
- pattern_part.nodes.push_back(ctx->nodePattern()->accept(this).as<Node>());
+ pattern_part.output_id = new_id();
+ pattern_part.nodes.push_back(
+ ctx->nodePattern()->accept(this).as<std::string>());
for (auto *pattern_element_chain : ctx->patternElementChain()) {
- auto element =
- pattern_element_chain->accept(this).as<std::pair<Relationship, Node>>();
+ auto element = pattern_element_chain->accept(this)
+ .as<std::pair<std::string, std::string>>();
pattern_part.relationships.push_back(element.first);
pattern_part.nodes.push_back(element.second);
}
@@ -121,17 +167,61 @@ antlrcpp::Any CypherMainVisitor::visitPatternElement(
antlrcpp::Any CypherMainVisitor::visitPatternElementChain(
CypherParser::PatternElementChainContext *ctx) {
- return std::pair<Relationship, Node>(
- ctx->relationshipPattern()->accept(this).as<Relationship>(),
- ctx->nodePattern()->accept(this).as<Node>());
+ return std::pair<std::string, std::string>(
+ ctx->relationshipPattern()->accept(this).as<std::string>(),
+ ctx->nodePattern()->accept(this).as<std::string>());
}
antlrcpp::Any CypherMainVisitor::visitRelationshipPattern(
CypherParser::RelationshipPatternContext *ctx) {
+ bool new_relationship = true;
Relationship relationship;
- relationship.output_identifier = new_identifier();
if (ctx->relationshipDetail()) {
- VisitRelationshipDetail(ctx->relationshipDetail(), relationship);
+ if (ctx->relationshipDetail()->variable()) {
+ auto variable =
+ ctx->relationshipDetail()->variable()->accept(this).as<std::string>();
+ auto &curr_id_map = ids_map_.back();
+ if (curr_id_map.find(variable) != curr_id_map.end()) {
+ if (!symbol_table_[curr_id_map[variable]].is<Relationship>()) {
+ throw SemanticException();
+ }
+ new_relationship = false;
+ relationship = symbol_table_[curr_id_map[variable]].as<Relationship>();
+ } else {
+ relationship.output_id = new_id();
+ curr_id_map[variable] = relationship.output_id;
+ }
+ }
+ if (!new_relationship && (ctx->relationshipDetail()->relationshipTypes() ||
+ ctx->relationshipDetail()->properties() ||
+ ctx->relationshipDetail()->rangeLiteral())) {
+ // Neo4j doesn't allow multiple edges with same variable name, but if we
+ // are going to support different types of morphisms then there is no
+ // reason to disallow that.
+ throw SemanticException();
+ }
+ if (ctx->relationshipDetail()->relationshipTypes()) {
+ relationship.types = ctx->relationshipDetail()
+ ->relationshipTypes()
+ ->accept(this)
+ .as<std::vector<std::string>>();
+ }
+ if (ctx->relationshipDetail()->properties()) {
+ relationship.properties =
+ ctx->relationshipDetail()
+ ->properties()
+ ->accept(this)
+ .as<std::unordered_map<std::string, std::string>>();
+ }
+ if (ctx->relationshipDetail()->rangeLiteral()) {
+ relationship.has_range = true;
+ auto range = ctx->relationshipDetail()
+ ->rangeLiteral()
+ ->accept(this)
+ .as<std::pair<int64_t, int64_t>>();
+ relationship.lower_bound = range.first;
+ relationship.upper_bound = range.second;
+ }
}
if (ctx->leftArrowHead() && !ctx->rightArrowHead()) {
relationship.direction = Relationship::Direction::LEFT;
@@ -142,42 +232,16 @@ antlrcpp::Any CypherMainVisitor::visitRelationshipPattern(
// grammar.
relationship.direction = Relationship::Direction::BOTH;
}
- symbol_table_[relationship.output_identifier] = relationship;
- return relationship;
+ symbol_table_[relationship.output_id] = relationship;
+ return relationship.output_id;
}
antlrcpp::Any CypherMainVisitor::visitRelationshipDetail(
CypherParser::RelationshipDetailContext *) {
- debug_assert(false, "Unimplemented.");
+ debug_assert(false, "Should never be called. See documentation in hpp.");
return 0;
}
-void CypherMainVisitor::VisitRelationshipDetail(
- CypherParser::RelationshipDetailContext *ctx, Relationship &relationship) {
- if (ctx->variable()) {
- identifiers_map_[ctx->variable()->accept(this).as<std::string>()] =
- relationship.output_identifier;
- }
- if (ctx->relationshipTypes()) {
- relationship.types =
- ctx->relationshipTypes()->accept(this).as<std::vector<std::string>>();
- }
- if (ctx->properties()) {
- relationship.properties =
- ctx->properties()
- ->accept(this)
- .as<std::unordered_map<std::string,
- CypherParser::ExpressionContext *>>();
- }
- if (ctx->rangeLiteral()) {
- relationship.has_range = true;
- auto range =
- ctx->rangeLiteral()->accept(this).as<std::pair<int64_t, int64_t>>();
- relationship.lower_bound = range.first;
- relationship.upper_bound = range.second;
- }
-}
-
antlrcpp::Any CypherMainVisitor::visitRelationshipTypes(
CypherParser::RelationshipTypesContext *ctx) {
std::vector<std::string> types;
@@ -215,6 +279,238 @@ antlrcpp::Any CypherMainVisitor::visitRangeLiteral(
}
}
+antlrcpp::Any CypherMainVisitor::visitExpression(
+ CypherParser::ExpressionContext *ctx) {
+ return visitChildren(ctx);
+}
+
+// OR.
+antlrcpp::Any CypherMainVisitor::visitExpression12(
+ CypherParser::Expression12Context *ctx) {
+ return LeftAssociativeOperatorExpression(ctx->expression11(),
+ Function::LOGICAL_OR);
+}
+
+// XOR.
+antlrcpp::Any CypherMainVisitor::visitExpression11(
+ CypherParser::Expression11Context *ctx) {
+ return LeftAssociativeOperatorExpression(ctx->expression10(),
+ Function::LOGICAL_XOR);
+}
+
+// AND.
+antlrcpp::Any CypherMainVisitor::visitExpression10(
+ CypherParser::Expression10Context *ctx) {
+ return LeftAssociativeOperatorExpression(ctx->expression9(),
+ Function::LOGICAL_AND);
+}
+
+// NOT.
+antlrcpp::Any CypherMainVisitor::visitExpression9(
+ CypherParser::Expression9Context *ctx) {
+ // TODO: make template similar to LeftAssociativeOperatorExpression for unary
+ // expresssions.
+ auto operand = ctx->expression8()->accept(this).as<std::string>();
+ for (int i = 0; i < (int)ctx->NOT().size(); ++i) {
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] = SimpleExpression{Function::LOGICAL_NOT, {operand}};
+ operand = lhs_id;
+ }
+ return operand;
+}
+
+// Comparisons.
+antlrcpp::Any CypherMainVisitor::visitExpression8(
+ CypherParser::Expression8Context *ctx) {
+ if (!ctx->partialComparisonExpression().size()) {
+ // There is no comparison operators. We generate expression7.
+ return ctx->expression7()->accept(this);
+ }
+
+ // There is at least one comparison. We need to generate code for each of
+ // them. We don't call visitPartialComparisonExpression but do everything in
+ // this function and call expression7-s directly. Since every expression7
+ // can be generated twice (because it can appear in two comparisons) code
+ // generated by whole subtree of expression7 must not have any sideeffects.
+ // We handle chained comparisons as defined by mathematics, neo4j handles
+ // them in a very interesting, illogical and incomprehensible way. For
+ // example in neo4j:
+ // 1 < 2 < 3 -> true,
+ // 1 < 2 < 3 < 4 -> false,
+ // 5 > 3 < 5 > 3 -> true,
+ // 4 <= 5 < 7 > 6 -> false
+ // All of those comparisons evaluate to true in memgraph.
+ std::vector<std::string> children_ids;
+ children_ids.push_back(ctx->expression7()->accept(this).as<std::string>());
+ auto partial_comparison_expressions = ctx->partialComparisonExpression();
+ for (auto *child : partial_comparison_expressions) {
+ children_ids.push_back(child->accept(this).as<std::string>());
+ }
+
+ // Make all comparisons.
+ std::string first_operand = children_ids[0];
+ std::vector<std::string> comparison_ids;
+ for (int i = 0; i < (int)partial_comparison_expressions.size(); ++i) {
+ auto *expr = partial_comparison_expressions[i];
+ auto op = [](CypherParser::PartialComparisonExpressionContext *expr) {
+ if (expr->getToken(kEqTokenId, 0)) {
+ return Function::EQ;
+ } else if (expr->getToken(kNeTokenId1, 0) ||
+ expr->getToken(kNeTokenId2, 0)) {
+ return Function::NE;
+ } else if (expr->getToken(kLtTokenId, 0)) {
+ return Function::LT;
+ } else if (expr->getToken(kGtTokenId, 0)) {
+ return Function::GT;
+ } else if (expr->getToken(kLeTokenId, 0)) {
+ return Function::LE;
+ } else if (expr->getToken(kGeTokenId, 0)) {
+ return Function::GE;
+ }
+ assert(false);
+ return Function::GE;
+ }(expr);
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] =
+ SimpleExpression{op, {first_operand, children_ids[i + 1]}};
+ first_operand = lhs_id;
+ comparison_ids.push_back(lhs_id);
+ }
+
+ first_operand = comparison_ids[0];
+ // Calculate logical and of results of comparisons.
+ for (int i = 1; i < (int)comparison_ids.size(); ++i) {
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] = SimpleExpression{
+ Function::LOGICAL_AND, {first_operand, comparison_ids[i]}};
+ first_operand = lhs_id;
+ }
+ return first_operand;
+}
+
+antlrcpp::Any CypherMainVisitor::visitPartialComparisonExpression(
+ CypherParser::PartialComparisonExpressionContext *) {
+ debug_assert(false, "Should never be called. See documentation in hpp.");
+ return 0;
+}
+
+// Addition and subtraction.
+antlrcpp::Any CypherMainVisitor::visitExpression7(
+ CypherParser::Expression7Context *ctx) {
+ return LeftAssociativeOperatorExpression(
+ ctx->expression6(),
+ MapTokensToOperators(ctx, {{kPlusTokenId, Function::ADDITION},
+ {kMinusTokenId, Function::SUBTRACTION}}));
+}
+
+// Multiplication, division, modding.
+antlrcpp::Any CypherMainVisitor::visitExpression6(
+ CypherParser::Expression6Context *ctx) {
+ return LeftAssociativeOperatorExpression(
+ ctx->expression5(),
+ MapTokensToOperators(ctx, {{kMultTokenId, Function::MULTIPLICATION},
+ {kDivTokenId, Function::DIVISION},
+ {kModTokenId, Function::MODULO}}));
+}
+
+// Power.
+antlrcpp::Any CypherMainVisitor::visitExpression5(
+ CypherParser::Expression5Context *ctx) {
+ if (ctx->expression4().size() > 1u) {
+ // TODO: implement power operator. In neo4j power is right associative and
+ // int^int -> float.
+ throw SemanticException();
+ }
+ return visitChildren(ctx);
+}
+
+// Unary minus and plus.
+antlrcpp::Any CypherMainVisitor::visitExpression4(
+ CypherParser::Expression4Context *ctx) {
+ auto ops =
+ MapTokensToOperators(ctx, {{kUnaryPlusTokenId, Function::UNARY_PLUS},
+ {kUnaryMinusTokenId, Function::UNARY_MINUS}});
+ auto operand = ctx->expression3()->accept(this).as<std::string>();
+ for (int i = 0; i < (int)ops.size(); ++i) {
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] = SimpleExpression{ops[i], {operand}};
+ operand = lhs_id;
+ }
+ return operand;
+}
+
+antlrcpp::Any CypherMainVisitor::visitExpression3(
+ CypherParser::Expression3Context *ctx) {
+ // If there is only one child we don't need to generate any code in this since
+ // that child is expression2. Other operations are not implemented at the
+ // moment.
+ // TODO: implement this.
+ if (ctx->children.size() > 1u) {
+ throw SemanticException();
+ }
+ return visitChildren(ctx);
+}
+
+antlrcpp::Any CypherMainVisitor::visitExpression2(
+ CypherParser::Expression2Context *ctx) {
+ if (ctx->nodeLabels().size()) {
+ // TODO: Implement this. We don't currently support label checking in
+ // expresssion.
+ throw SemanticException();
+ }
+ auto operand = ctx->atom()->accept(this).as<std::string>();
+ for (int i = 0; i < (int)ctx->propertyLookup().size(); ++i) {
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] =
+ SimpleExpression{Function::PROPERTY_GETTER, {operand}};
+ operand = lhs_id;
+ }
+ return operand;
+}
+
+antlrcpp::Any CypherMainVisitor::visitAtom(CypherParser::AtomContext *ctx) {
+ if (ctx->literal()) {
+ // This is not very nice since we didn't parse text given in query, but we
+ // left that job to the code generator. Correct approach would be to parse
+ // it and store it in a structure of appropriate type, int, string... And
+ // then code generator would generate its own text based on structure. This
+ // is also a security risk if code generator doesn't parse and escape
+ // text appropriately. At the moment we don;t care much since literal will
+ // appear only in tests and real queries will be stripped.
+ // TODO: Either parse it correctly or raise exception. If exception is
+ // raised it tests should also use params instead of literals.
+ auto text = ctx->literal()->getText();
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] = SimpleExpression{Function::LITERAL, {text}};
+ return lhs_id;
+ } else if (ctx->parameter()) {
+ // This is once again potential security risk. We shouldn't output text
+ // given in user query as parameter name directly to the code. Stripper
+ // should either replace user's parameter name with generic one or we should
+ // allow only parameters with numeric names. At the moment this is not a
+ // problem since we don't accept user's parameters but only ours.
+ // TODO: revise this.
+ auto text = ctx->literal()->getText();
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] = SimpleExpression{Function::PARAMETER, {text}};
+ return lhs_id;
+ } else if (ctx->parenthesizedExpression()) {
+ return ctx->parenthesizedExpression()->accept(this);
+ } else if (ctx->variable()) {
+ // TODO: revise this. Is it possible in some atom to use not declared
+ // variable. Is it correct to always use last ids_map?
+ auto &curr_id_map = ids_map_.back();
+ auto variable = ctx->variable()->accept(this).as<std::string>();
+ if (curr_id_map.find(variable) == curr_id_map.end()) {
+ throw SemanticException();
+ }
+ return curr_id_map[variable];
+ }
+ // TODO: Implement this. We don't support comprehensions, functions,
+ // filtering... at the moment.
+ throw SemanticException();
+}
+
antlrcpp::Any CypherMainVisitor::visitIntegerLiteral(
CypherParser::IntegerLiteralContext *ctx) {
int64_t t = 0LL;
@@ -225,3 +521,5 @@ antlrcpp::Any CypherMainVisitor::visitIntegerLiteral(
}
return t;
}
+}
+}
diff --git a/src/query/backend/cpp/cypher_main_visitor.hpp b/src/query/backend/cpp/cypher_main_visitor.hpp
index f5fc94d69..3dfab0a5d 100644
--- a/src/query/backend/cpp/cypher_main_visitor.hpp
+++ b/src/query/backend/cpp/cypher_main_visitor.hpp
@@ -5,136 +5,288 @@
#include "antlr4-runtime.h"
#include "query/backend/cpp/compiler_structures.hpp"
+namespace backend {
+namespace cpp {
+
using antlropencypher::CypherParser;
class CypherMainVisitor : public antlropencypher::CypherBaseVisitor {
+ private:
+ // Return new output code id.
+ // TODO: Should we generate ids with more readable names: node_1,
+ // relationship_5, temporary_2...?
+ std::string new_id() const {
+ static int next_id = 0;
+ return "id" + std::to_string(next_id++);
+ }
+
+ template <typename TExpression>
+ antlrcpp::Any LeftAssociativeOperatorExpression(
+ std::vector<TExpression *> children, std::vector<Function> ops) {
+ assert(children.size());
+ std::vector<std::string> children_ids;
+
+ for (auto *child : children) {
+ children_ids.push_back(child->accept(this).template as<std::string>());
+ }
+
+ std::string first_operand = children_ids[0];
+ for (int i = 0; i < (int)ops.size(); ++i) {
+ auto lhs_id = new_id();
+ symbol_table_[lhs_id] =
+ SimpleExpression{ops[i], {first_operand, children_ids[i + 1]}};
+ first_operand = lhs_id;
+ }
+ return first_operand;
+ }
+
+ template <typename TExpression>
+ antlrcpp::Any LeftAssociativeOperatorExpression(
+ std::vector<TExpression *> children, Function op) {
+ return LeftAssociativeOperatorExpression(
+ children, std::vector<Function>((int)children.size() - 1, op));
+ }
+
/**
- * Creates Node and stores it in symbol_table_. If variable is defined it is
- * stored in identifiers_map_.
- *
- * @return Node.
- */
+ * Creates Node and stores it in symbol_table_. If variable is defined it is
+ * stored in ids_map_.
+ *
+ * @return string - node id.
+ */
antlrcpp::Any visitNodePattern(
CypherParser::NodePatternContext *ctx) override;
/**
- * @return vector<string> labels.
- */
+ * @return vector<string> labels.
+ */
antlrcpp::Any visitNodeLabels(CypherParser::NodeLabelsContext *ctx) override;
/**
- * @return unordered_map<string, ExpressionContext*> properties.
- */
+ * @return unordered_map<string, string> properties - property key to
+ * expression id.
+ */
antlrcpp::Any visitProperties(CypherParser::PropertiesContext *ctx) override;
/**
- * @return unordered_map<string, ExpressionContext*> map.
- */
+ * @return unordered_map<string, string> map - key to expression id.
+ */
antlrcpp::Any visitMapLiteral(CypherParser::MapLiteralContext *ctx) override;
/**
- * @return string.
- */
+ * @return string.
+ */
antlrcpp::Any visitSymbolicName(
CypherParser::SymbolicNameContext *ctx) override;
/**
- * @return vector<PatternPart> pattern.
- */
+ * @return vector<PatternPart> pattern.
+ */
antlrcpp::Any visitPattern(CypherParser::PatternContext *ctx) override;
/**
- * Stores PatternPart in symbol_table_. If variable is defined it is stored in
- * identifiers_map_.
- *
- * @return PatternPart.
- */
+ * Stores PatternPart in symbol_table_. If variable is defined it is stored
+ *in
+ * ids_map_.
+ *
+ * @return string - pattern part id.
+ */
antlrcpp::Any visitPatternPart(
CypherParser::PatternPartContext *ctx) override;
/**
- * Creates PatternPart.
- *
- * @return PatternPart.
- */
+ * Creates PatternPart.
+ *
+ * @return PatternPart.
+ */
antlrcpp::Any visitPatternElement(
CypherParser::PatternElementContext *ctx) override;
/**
- * @return pair<Relationship, Node>
- */
+ * @return pair<string, string> - node and relationship ids.
+ */
antlrcpp::Any visitPatternElementChain(
CypherParser::PatternElementChainContext *ctx) override;
/**
- * Creates Relationship and stores it in symbol_table_.
- *
- */
+ * Creates Relationship and stores it in symbol_table_. If variable is defined
+ * it is stored in symbol_table_.
+ *
+ * @return string - relationship id.
+ */
antlrcpp::Any visitRelationshipPattern(
CypherParser::RelationshipPatternContext *ctx) override;
/**
- * This should never be called. Call VisitRelationshipDetail with already
- * created Relationship instead.
- */
+ * This should never be called. Everything is done directly in
+ * visitRelationshipPattern.
+ */
antlrcpp::Any visitRelationshipDetail(
CypherParser::RelationshipDetailContext *ctx) override;
-
/**
- * If variable is defined it is stored in symbol_table_. Relationship is
- * filled with properties, types and range if provided.
- * Use this instead of antlr generated visitRelationshipDetail with already
- * created Relationship. If we should have used visitRelationshipDetail
- * (relationshipDetail is optional production in relationshipPattern) then we
- * would have needed to return not completely initialised Relationship.
- */
- void VisitRelationshipDetail(CypherParser::RelationshipDetailContext *ctx,
- Relationship &relationship);
-
- /**
- * @return vector<string>.
- */
+ * @return vector<string>.
+ */
antlrcpp::Any visitRelationshipTypes(
CypherParser::RelationshipTypesContext *ctx) override;
/**
- * @return int64_t.
- */
- antlrcpp::Any visitIntegerLiteral(
- CypherParser::IntegerLiteralContext *ctx) override;
-
- /**
- * @return pair<int64_t, int64_t>.
- */
+ * @return pair<int64_t, int64_t>.
+ */
antlrcpp::Any visitRangeLiteral(
CypherParser::RangeLiteralContext *ctx) override;
+ /**
+ * Top level expression.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression(CypherParser::ExpressionContext *ctx) override;
+
+ /**
+ * OR.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression12(
+ CypherParser::Expression12Context *ctx) override;
+
+ /**
+ * XOR.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression11(
+ CypherParser::Expression11Context *ctx) override;
+
+ /**
+ * AND.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression10(
+ CypherParser::Expression10Context *ctx) override;
+
+ /**
+ * NOT.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression9(
+ CypherParser::Expression9Context *ctx) override;
+
+ /**
+ * Comparisons.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression8(
+ CypherParser::Expression8Context *ctx) override;
+
+ /**
+ * Never call this. Everything related to generating code for comparison
+ * operators should be done in visitExpression8.
+ */
+ antlrcpp::Any visitPartialComparisonExpression(
+ CypherParser::PartialComparisonExpressionContext *ctx) override;
+
+ /**
+ * Addition and subtraction.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression7(
+ CypherParser::Expression7Context *ctx) override;
+
+ /**
+ * Multiplication, division, modding.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression6(
+ CypherParser::Expression6Context *ctx) override;
+
+ /**
+ * Power.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression5(
+ CypherParser::Expression5Context *ctx) override;
+
+ /**
+ * Unary minus and plus.
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression4(
+ CypherParser::Expression4Context *ctx) override;
+
+ /**
+ * Element of a list, range of a list...
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression3(
+ CypherParser::Expression3Context *ctx) override;
+
+ /**
+ * Property lookup, test for node labels existence...
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitExpression2(
+ CypherParser::Expression2Context *ctx) override;
+
+ /**
+ * Literals, params, list comprehension...
+ *
+ * @return string - expression id.
+ */
+ antlrcpp::Any visitAtom(CypherParser::AtomContext *ctx) override;
+
+ // antlrcpp::Any visitLiteral(CypherParser::LiteralContext *ctx) override {
+ // return visitChildren(ctx);
+ // }
+ //
+ // antlrcpp::Any visitBooleanLiteral(
+ // CypherParser::BooleanLiteralContext *ctx) override {
+ // return visitChildren(ctx);
+ // }
+ //
+ // antlrcpp::Any visitListLiteral(
+ // CypherParser::ListLiteralContext *ctx) override {
+ // return visitChildren(ctx);
+ // }
+ //
+ // antlrcpp::Any visitParenthesizedExpression(
+ // CypherParser::ParenthesizedExpressionContext *ctx) override {
+ // return visitChildren(ctx);
+ // }
+
+ /**
+ * @return int64_t.
+ */
+ antlrcpp::Any visitIntegerLiteral(
+ CypherParser::IntegerLiteralContext *ctx) override;
+
public:
- // TODO: These temporary getters should eventually be replaced with something
+ // TODO: These temporary getters should eventually be replaced with
+ // something
// else once we figure out where and how those strctures will be used.
- // Currently there are needed for testing. cypher_main_visitor test should be
+ // Currently there are needed for testing. cypher_main_visitor test should
+ // be
// refactored once these getters are deleted.
- const std::unordered_map<std::string, std::string> &identifiers_map() const {
- return identifiers_map_;
- }
- const std::unordered_map<std::string, antlrcpp::Any> &symbol_table() const {
- return symbol_table_;
- }
+ const auto &ids_map() const { return ids_map_; }
+ const auto &symbol_table() const { return symbol_table_; }
private:
- // Return new output code identifier.
- // TODO: Should we generate identifiers with more readable names: node_1,
- // relationship_5, ...?
- std::string new_identifier() const {
- static int next_identifier = 0;
- return "id" + std::to_string(next_identifier++);
- }
+ // Mapping of ids (nodes, relationships, values, lists ...) from
+ // query
+ // code to id that is used in generated code;
+ std::vector<std::unordered_map<std::string, std::string>> ids_map_{1};
- // Mapping of identifiers (nodes, relationships, values, lists ...) from query
- // code to identifier that is used in generated code;
- std::unordered_map<std::string, std::string> identifiers_map_;
-
- // Mapping of output (generated) code identifiers to appropriate parser
+ // Mapping of output (generated) code ids to appropriate parser
// structure.
std::unordered_map<std::string, antlrcpp::Any> symbol_table_;
};
+}
+}
diff --git a/src/query/backend/cpp/named_antlr_tokens.hpp b/src/query/backend/cpp/named_antlr_tokens.hpp
new file mode 100644
index 000000000..248814cb8
--- /dev/null
+++ b/src/query/backend/cpp/named_antlr_tokens.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "query/frontend/opencypher/generated/CypherBaseVisitor.h"
+
+using antlropencypher::CypherParser;
+
+// List of unnamed tokens visitor needs to use. This should be reviewed on every
+// grammar change since even changes in ordering of rules will cause antlr to
+// generate different constants for unnamed tokens.
+const auto kDotsTokenId = CypherParser::T__11; // ..
+const auto kEqTokenId = CypherParser::T__2; // =
+const auto kNeTokenId1 = CypherParser::T__18; // <>
+const auto kNeTokenId2 = CypherParser::T__19; // !=
+const auto kLtTokenId = CypherParser::T__20; // <
+const auto kGtTokenId = CypherParser::T__21; // >
+const auto kLeTokenId = CypherParser::T__22; // <=
+const auto kGeTokenId = CypherParser::T__23; // >=
+const auto kPlusTokenId = CypherParser::T__12; // +
+const auto kMinusTokenId = CypherParser::T__13; // -
+const auto kMultTokenId = CypherParser::T__4; // *
+const auto kDivTokenId = CypherParser::T__14; // /
+const auto kModTokenId = CypherParser::T__15; // %
+const auto kUnaryPlusTokenId = CypherParser::T__12; // +
+const auto kUnaryMinusTokenId = CypherParser::T__13; // -
diff --git a/src/query/backend/cpp/runtime_functions.cpp b/src/query/backend/cpp/runtime_functions.cpp
new file mode 100644
index 000000000..613498572
--- /dev/null
+++ b/src/query/backend/cpp/runtime_functions.cpp
@@ -0,0 +1,20 @@
+#include "query/backend/cpp/runtime_functions.hpp"
+
+#include "storage/record_accessor.hpp"
+#include "storage/vertex_accessor.hpp"
+#include "storage/edge_accessor.hpp"
+
+namespace backend {
+namespace cpp {
+
+TypedValue GetProperty(const TypedValue &t, const std::string &key) {
+ if (t.type() == TypedValue::Type::Vertex) {
+ return t.Value<VertexAccessor>().PropsAt(key);
+ } else if (t.type() == TypedValue::Type::Edge) {
+ return t.Value<EdgeAccessor>().PropsAt(key);
+ } else {
+ throw TypedValueException("Unsupported type.");
+ }
+}
+}
+}
diff --git a/src/query/backend/cpp/runtime_functions.hpp b/src/query/backend/cpp/runtime_functions.hpp
new file mode 100644
index 000000000..16ca0fe6f
--- /dev/null
+++ b/src/query/backend/cpp/runtime_functions.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "query/backend/cpp/typed_value.hpp"
+
+namespace backend {
+namespace cpp {
+
+TypedValue GetProperty(const TypedValue &t, const std::string &key);
+}
+}
diff --git a/src/query/backend/cpp/typed_value.cpp b/src/query/backend/cpp/typed_value.cpp
index 084f728f3..c3a91e723 100644
--- a/src/query/backend/cpp/typed_value.cpp
+++ b/src/query/backend/cpp/typed_value.cpp
@@ -32,7 +32,7 @@ TypedValue::TypedValue(const PropertyValue& value) {
new (&list_v) std::vector<TypedValue>(vec.begin(), vec.end());
return;
}
- permanent_fail("Unsupported PropertyValue::Type");
+ permanent_fail("Unsupported type");
}
TypedValue::operator PropertyValue() const {
@@ -51,73 +51,86 @@ TypedValue::operator PropertyValue() const {
return PropertyValue(
std::vector<PropertyValue>(list_v.begin(), list_v.end()));
default:
- permanent_fail("Unsupported PropertyValue::Type");
+ throw TypedValueException(
+ "Unsupported conversion from TypedValue to PropertyValue");
}
- permanent_fail("Unsupported PropertyValue::Type");
}
+// TODO: Refactor this. Value<bool> should be ValueBool. If we do it in that way
+// we could return reference for complex types and value for primitive types.
+// Other solution would be to add additional overloads for references, for
+// example Value<string&>.
// Value extraction template instantiations
template <>
bool TypedValue::Value<bool>() const {
- debug_assert(type_ == TypedValue::Type::Bool,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::Bool) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return bool_v;
}
template <>
int TypedValue::Value<int>() const {
- debug_assert(type_ == TypedValue::Type::Int,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::Int) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return int_v;
}
template <>
double TypedValue::Value<double>() const {
- debug_assert(type_ == TypedValue::Type::Double,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::Double) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return double_v;
}
template <>
std::string TypedValue::Value<std::string>() const {
- debug_assert(type_ == TypedValue::Type::String,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::String) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return string_v;
}
template <>
std::vector<TypedValue> TypedValue::Value<std::vector<TypedValue>>() const {
- debug_assert(type_ == TypedValue::Type::List,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::List) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return list_v;
}
template <>
std::map<std::string, TypedValue>
TypedValue::Value<std::map<std::string, TypedValue>>() const {
- debug_assert(type_ == TypedValue::Type::Map,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::Map) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return map_v;
}
template <>
VertexAccessor TypedValue::Value<VertexAccessor>() const {
- debug_assert(type_ == TypedValue::Type::Vertex,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::Vertex) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return vertex_v;
}
template <>
EdgeAccessor TypedValue::Value<EdgeAccessor>() const {
- debug_assert(type_ == TypedValue::Type::Edge,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::Edge) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return edge_v;
}
template <>
Path TypedValue::Value<Path>() const {
- debug_assert(type_ == TypedValue::Type::Path,
- "Incompatible template param and type");
+ if (type_ != TypedValue::Type::Path) {
+ throw TypedValueException("Incompatible template param and type");
+ }
return path_v;
}
@@ -308,9 +321,9 @@ double ToDouble(const TypedValue& value) {
return (double)value.Value<int>();
case TypedValue::Type::Double:
return value.Value<double>();
-
default:
- permanent_fail("Unsupported TypedValue::Type");
+ throw TypedValueException(
+ "Unsupported TypedValue::Type conversion to double");
}
}
@@ -324,22 +337,25 @@ TypedValue operator<(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::String ||
b.type() == TypedValue::Type::String) {
- if (a.type() != b.type())
+ if (a.type() != b.type()) {
throw TypedValueException("Invalid equality operand types({} + {})",
a.type(), b.type());
- else
+ } else {
return a.Value<std::string>() < b.Value<std::string>();
+ }
}
// at this point we only have int and double
if (a.type() == TypedValue::Type::Double ||
- b.type() == TypedValue::Type::Double)
+ b.type() == TypedValue::Type::Double) {
return ToDouble(a) < ToDouble(b);
- else
+ } else {
return a.Value<int>() < b.Value<int>();
+ }
}
-// TODO: 2 = "2" -> false, I don't this is handled correctly at the moment.
+// TODO: 2 = "2" -> false, I don't think this is handled correctly at the
+// moment.
TypedValue operator==(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::Null || b.type() == TypedValue::Type::Null)
return TypedValue::Null;
@@ -349,7 +365,8 @@ TypedValue operator==(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::List &&
b.type() == TypedValue::Type::List) {
// Potential optimisation: There is no need to copies of both lists to
- // compare them. If operator becomes a friend of TypedValue class then we
+ // compare them. If operator becomes a friend of TypedValue class then
+ // we
// can compare list_v-s directly.
auto list1 = a.Value<std::vector<TypedValue>>();
auto list2 = b.Value<std::vector<TypedValue>>();
@@ -361,7 +378,8 @@ TypedValue operator==(const TypedValue& a, const TypedValue& b) {
}
return true;
}
- // We are not compatible with neo4j at this point. In neo4j 2 = [2] compares
+ // We are not compatible with neo4j at this point. In neo4j 2 = [2]
+ // compares
// to true. That is not the end of unselfishness of developers at neo4j so
// they allow us to use as many braces as we want to get to the truth in
// list comparison, so [[2]] = [[[[[[2]]]]]] compares to true in neo4j as
@@ -373,27 +391,30 @@ TypedValue operator==(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::String ||
b.type() == TypedValue::Type::String) {
- if (a.type() != b.type())
+ if (a.type() != b.type()) {
throw TypedValueException("Invalid equality operand types({} + {})",
a.type(), b.type());
- else
+ } else {
return a.Value<std::string>() == b.Value<std::string>();
+ }
}
if (a.type() == TypedValue::Type::Bool ||
b.type() == TypedValue::Type::Bool) {
- if (a.type() != b.type())
+ if (a.type() != b.type()) {
throw TypedValueException("Invalid equality operand types({} + {})",
a.type(), b.type());
- else
+ } else {
return a.Value<bool>() == b.Value<bool>();
+ }
}
// at this point we only have int and double
if (a.type() == TypedValue::Type::Double ||
b.type() == TypedValue::Type::Double) {
return ToDouble(a) == ToDouble(b);
- } else
+ } else {
return a.Value<int>() == b.Value<int>();
+ }
}
TypedValue operator!(const TypedValue& a) {
@@ -402,7 +423,6 @@ TypedValue operator!(const TypedValue& a) {
return TypedValue::Null;
case TypedValue::Type::Bool:
return TypedValue(!a.Value<bool>());
-
default:
throw TypedValueException("Invalid logical not operand type (!{})",
a.type());
@@ -423,10 +443,10 @@ std::string ValueToString(const TypedValue& value) {
return std::to_string(value.Value<int>());
case TypedValue::Type::Double:
return fmt::format("{}", value.Value<double>());
-
// unsupported situations
default:
- permanent_fail("Unsupported TypedValue::Type");
+ throw TypedValueException(
+ "Unsupported TypedValue::Type conversion to string");
}
}
@@ -438,7 +458,6 @@ TypedValue operator-(const TypedValue& a) {
return -a.Value<int>();
case TypedValue::Type::Double:
return -a.Value<double>();
-
default:
throw TypedValueException("Invalid unary minus operand type (-{})",
a.type());
@@ -501,8 +520,9 @@ TypedValue operator+(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::Double ||
b.type() == TypedValue::Type::Double) {
return ToDouble(a) + ToDouble(b);
- } else
+ } else {
return a.Value<int>() + b.Value<int>();
+ }
}
TypedValue operator-(const TypedValue& a, const TypedValue& b) {
@@ -515,8 +535,9 @@ TypedValue operator-(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::Double ||
b.type() == TypedValue::Type::Double) {
return ToDouble(a) - ToDouble(b);
- } else
+ } else {
return a.Value<int>() - b.Value<int>();
+ }
}
TypedValue operator/(const TypedValue& a, const TypedValue& b) {
@@ -529,8 +550,9 @@ TypedValue operator/(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::Double ||
b.type() == TypedValue::Type::Double) {
return ToDouble(a) / ToDouble(b);
- } else
+ } else {
return a.Value<int>() / b.Value<int>();
+ }
}
TypedValue operator*(const TypedValue& a, const TypedValue& b) {
@@ -543,8 +565,9 @@ TypedValue operator*(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::Double ||
b.type() == TypedValue::Type::Double) {
return ToDouble(a) * ToDouble(b);
- } else
+ } else {
return a.Value<int>() * b.Value<int>();
+ }
}
TypedValue operator%(const TypedValue& a, const TypedValue& b) {
@@ -557,8 +580,9 @@ TypedValue operator%(const TypedValue& a, const TypedValue& b) {
if (a.type() == TypedValue::Type::Double ||
b.type() == TypedValue::Type::Double) {
return (double)fmod(ToDouble(a), ToDouble(b));
- } else
+ } else {
return a.Value<int>() % b.Value<int>();
+ }
}
inline bool IsLogicallyOk(const TypedValue& a) {
@@ -570,23 +594,41 @@ inline bool IsLogicallyOk(const TypedValue& a) {
TypedValue operator&&(const TypedValue& a, const TypedValue& b) {
if (IsLogicallyOk(a) && IsLogicallyOk(b)) {
if (a.type() == TypedValue::Type::Null ||
- b.type() == TypedValue::Type::Null)
+ b.type() == TypedValue::Type::Null) {
return TypedValue::Null;
- else
+ } else {
return a.Value<bool>() && b.Value<bool>();
- } else
+ }
+ } else {
throw TypedValueException("Invalid logical and operand types({} && {})",
a.type(), b.type());
+ }
}
TypedValue operator||(const TypedValue& a, const TypedValue& b) {
if (IsLogicallyOk(a) && IsLogicallyOk(b)) {
if (a.type() == TypedValue::Type::Null ||
- b.type() == TypedValue::Type::Null)
+ b.type() == TypedValue::Type::Null) {
return TypedValue::Null;
- else
+ } else {
return a.Value<bool>() || b.Value<bool>();
- } else
+ }
+ } else {
throw TypedValueException("Invalid logical and operand types({} && {})",
a.type(), b.type());
+ }
+}
+
+TypedValue operator^(const TypedValue& a, const TypedValue& b) {
+ if (IsLogicallyOk(a) && IsLogicallyOk(b)) {
+ if (a.type() == TypedValue::Type::Null ||
+ b.type() == TypedValue::Type::Null) {
+ return TypedValue::Null;
+ } else {
+ return static_cast<bool>(a.Value<bool>() ^ b.Value<bool>());
+ }
+ } else {
+ throw TypedValueException("Invalid logical and operand types({} && {})",
+ a.type(), b.type());
+ }
}
diff --git a/src/query/backend/cpp/typed_value.hpp b/src/query/backend/cpp/typed_value.hpp
index 84de55e30..3f3845863 100644
--- a/src/query/backend/cpp/typed_value.hpp
+++ b/src/query/backend/cpp/typed_value.hpp
@@ -16,6 +16,7 @@
typedef traversal_template::Path<VertexAccessor, EdgeAccessor> Path;
+// TODO: Neo4j does overflow checking. Should we also implement it?
/**
* Encapsulation of a value and it's type encapsulated in a class that has no
* compiled-time info about that type.
@@ -151,6 +152,10 @@ TypedValue operator%(const TypedValue& a, const TypedValue& b);
// binary bool operators
TypedValue operator&&(const TypedValue& a, const TypedValue& b);
TypedValue operator||(const TypedValue& a, const TypedValue& b);
+// binary bool xor, not power operator
+// Be careful: since ^ is binary operator and || and && are logical operators
+// they have different priority in c++.
+TypedValue operator^(const TypedValue& a, const TypedValue& b);
// stream output
std::ostream& operator<<(std::ostream& os, const TypedValue::Type type);
diff --git a/src/query/frontend/opencypher/generated/Cypher.tokens b/src/query/frontend/opencypher/generated/Cypher.tokens
index befaa26c3..cac3f8383 100644
--- a/src/query/frontend/opencypher/generated/Cypher.tokens
+++ b/src/query/frontend/opencypher/generated/Cypher.tokens
@@ -45,73 +45,70 @@ T__43=44
T__44=45
T__45=46
T__46=47
-T__47=48
-T__48=49
-StringLiteral=50
-EscapedChar=51
-HexInteger=52
-DecimalInteger=53
-OctalInteger=54
-HexLetter=55
-HexDigit=56
-Digit=57
-NonZeroDigit=58
-NonZeroOctDigit=59
-OctDigit=60
-ZeroDigit=61
-ExponentDecimalReal=62
-RegularDecimalReal=63
-UNION=64
-ALL=65
-OPTIONAL=66
-MATCH=67
-UNWIND=68
-AS=69
-MERGE=70
-ON=71
-CREATE=72
-SET=73
-DETACH=74
-DELETE=75
-REMOVE=76
-WITH=77
-DISTINCT=78
-RETURN=79
-ORDER=80
-BY=81
-L_SKIP=82
-LIMIT=83
-ASCENDING=84
-ASC=85
-DESCENDING=86
-DESC=87
-WHERE=88
-OR=89
-XOR=90
-AND=91
-NOT=92
-IN=93
-STARTS=94
-ENDS=95
-CONTAINS=96
-IS=97
-CYPHERNULL=98
-COUNT=99
-FILTER=100
-EXTRACT=101
-ANY=102
-NONE=103
-SINGLE=104
-TRUE=105
-FALSE=106
-UnescapedSymbolicName=107
-IdentifierStart=108
-IdentifierPart=109
-EscapedSymbolicName=110
-SP=111
-WHITESPACE=112
-Comment=113
-L_0X=114
+StringLiteral=48
+EscapedChar=49
+HexInteger=50
+DecimalInteger=51
+OctalInteger=52
+HexLetter=53
+HexDigit=54
+Digit=55
+NonZeroDigit=56
+NonZeroOctDigit=57
+OctDigit=58
+ZeroDigit=59
+ExponentDecimalReal=60
+RegularDecimalReal=61
+UNION=62
+ALL=63
+OPTIONAL=64
+MATCH=65
+UNWIND=66
+AS=67
+MERGE=68
+ON=69
+CREATE=70
+SET=71
+DETACH=72
+DELETE=73
+REMOVE=74
+WITH=75
+DISTINCT=76
+RETURN=77
+ORDER=78
+BY=79
+L_SKIP=80
+LIMIT=81
+ASCENDING=82
+ASC=83
+DESCENDING=84
+DESC=85
+WHERE=86
+OR=87
+XOR=88
+AND=89
+NOT=90
+IN=91
+STARTS=92
+ENDS=93
+CONTAINS=94
+IS=95
+CYPHERNULL=96
+COUNT=97
+FILTER=98
+EXTRACT=99
+ANY=100
+NONE=101
+SINGLE=102
+TRUE=103
+FALSE=104
+UnescapedSymbolicName=105
+IdentifierStart=106
+IdentifierPart=107
+EscapedSymbolicName=108
+SP=109
+WHITESPACE=110
+Comment=111
';'=1
','=2
'='=3
@@ -120,45 +117,43 @@ L_0X=114
'('=6
')'=7
'['=8
-'?'=9
-']'=10
-':'=11
-'|'=12
-'..'=13
-'+'=14
-'-'=15
-'/'=16
-'%'=17
-'^'=18
-'=~'=19
-'<>'=20
-'!='=21
-'<'=22
-'>'=23
-'<='=24
-'>='=25
-'.'=26
-'!'=27
-'{'=28
-'}'=29
-'$'=30
-'⟨'=31
-'〈'=32
-'﹤'=33
-'＜'=34
-'⟩'=35
-'〉'=36
-'﹥'=37
-'＞'=38
-''=39
-'‐'=40
-'‑'=41
-'‒'=42
-'–'=43
-'—'=44
-'―'=45
-'−'=46
-'﹘'=47
-'﹣'=48
-'－'=49
-'0'=61
+']'=9
+':'=10
+'|'=11
+'..'=12
+'+'=13
+'-'=14
+'/'=15
+'%'=16
+'^'=17
+'=~'=18
+'<>'=19
+'!='=20
+'<'=21
+'>'=22
+'<='=23
+'>='=24
+'.'=25
+'{'=26
+'}'=27
+'$'=28
+'⟨'=29
+'〈'=30
+'﹤'=31
+'＜'=32
+'⟩'=33
+'〉'=34
+'﹥'=35
+'＞'=36
+''=37
+'‐'=38
+'‑'=39
+'‒'=40
+'–'=41
+'—'=42
+'―'=43
+'−'=44
+'﹘'=45
+'﹣'=46
+'－'=47
+'0'=59
diff --git a/src/query/frontend/opencypher/generated/CypherBaseListener.cpp b/src/query/frontend/opencypher/generated/CypherBaseListener.cpp
index 05d7787f4..80f0fce2f 100644
--- a/src/query/frontend/opencypher/generated/CypherBaseListener.cpp
+++ b/src/query/frontend/opencypher/generated/CypherBaseListener.cpp
@@ -1,8 +1,9 @@
-// Generated from
-// /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4
-// by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+
#include "CypherBaseListener.h"
+
using namespace antlropencypher;
+
diff --git a/src/query/frontend/opencypher/generated/CypherBaseListener.h b/src/query/frontend/opencypher/generated/CypherBaseListener.h
index a7d2660ca..e03e89b78 100644
--- a/src/query/frontend/opencypher/generated/CypherBaseListener.h
+++ b/src/query/frontend/opencypher/generated/CypherBaseListener.h
@@ -1,5 +1,5 @@
-// Generated from /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
#pragma once
@@ -216,6 +216,9 @@ public:
virtual void enterListComprehension(CypherParser::ListComprehensionContext * /*ctx*/) override { }
virtual void exitListComprehension(CypherParser::ListComprehensionContext * /*ctx*/) override { }
+ virtual void enterPatternComprehension(CypherParser::PatternComprehensionContext * /*ctx*/) override { }
+ virtual void exitPatternComprehension(CypherParser::PatternComprehensionContext * /*ctx*/) override { }
+
virtual void enterPropertyLookup(CypherParser::PropertyLookupContext * /*ctx*/) override { }
virtual void exitPropertyLookup(CypherParser::PropertyLookupContext * /*ctx*/) override { }
diff --git a/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp b/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp
index f5f2c48e9..b2bd2f87d 100644
--- a/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp
+++ b/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp
@@ -1,8 +1,9 @@
-// Generated from
-// /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4
-// by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+
#include "CypherBaseVisitor.h"
+
using namespace antlropencypher;
+
diff --git a/src/query/frontend/opencypher/generated/CypherBaseVisitor.h b/src/query/frontend/opencypher/generated/CypherBaseVisitor.h
index 265e435e7..511bdecd5 100644
--- a/src/query/frontend/opencypher/generated/CypherBaseVisitor.h
+++ b/src/query/frontend/opencypher/generated/CypherBaseVisitor.h
@@ -1,5 +1,5 @@
-// Generated from /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
#pragma once
@@ -281,6 +281,10 @@ public:
return visitChildren(ctx);
}
+ virtual antlrcpp::Any visitPatternComprehension(CypherParser::PatternComprehensionContext *ctx) override {
+ return visitChildren(ctx);
+ }
+
virtual antlrcpp::Any visitPropertyLookup(CypherParser::PropertyLookupContext *ctx) override {
return visitChildren(ctx);
}
diff --git a/src/query/frontend/opencypher/generated/CypherLexer.cpp b/src/query/frontend/opencypher/generated/CypherLexer.cpp
index 24b3eb6ed..aa6be5fb7 100644
--- a/src/query/frontend/opencypher/generated/CypherLexer.cpp
+++ b/src/query/frontend/opencypher/generated/CypherLexer.cpp
@@ -1,22 +1,25 @@
-// Generated from
-// /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4
-// by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+
#include "CypherLexer.h"
+
using namespace antlr4;
using namespace antlropencypher;
-CypherLexer::CypherLexer(CharStream* input) : Lexer(input) {
- _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA,
- _sharedContextCache);
+CypherLexer::CypherLexer(CharStream *input) : Lexer(input) {
+ _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
}
-CypherLexer::~CypherLexer() { delete _interpreter; }
+CypherLexer::~CypherLexer() {
+ delete _interpreter;
+}
-std::string CypherLexer::getGrammarFileName() const { return "Cypher.g4"; }
+std::string CypherLexer::getGrammarFileName() const {
+ return "Cypher.g4";
+}
const std::vector<std::string>& CypherLexer::getRuleNames() const {
return _ruleNames;
@@ -30,13 +33,20 @@ const std::vector<std::string>& CypherLexer::getTokenNames() const {
return _tokenNames;
}
-dfa::Vocabulary& CypherLexer::getVocabulary() const { return _vocabulary; }
+dfa::Vocabulary& CypherLexer::getVocabulary() const {
+ return _vocabulary;
+}
const std::vector<uint16_t> CypherLexer::getSerializedATN() const {
return _serializedATN;
}
-const atn::ATN& CypherLexer::getATN() const { return _atn; }
+const atn::ATN& CypherLexer::getATN() const {
+ return _atn;
+}
+
+
+
// Static vars and initialization.
std::vector<dfa::DFA> CypherLexer::_decisionToDFA;
@@ -46,1331 +56,864 @@ atn::PredictionContextCache CypherLexer::_sharedContextCache;
atn::ATN CypherLexer::_atn;
std::vector<uint16_t> CypherLexer::_serializedATN;
-std::vector<std::string> CypherLexer::_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",
- "StringLiteral",
- "EscapedChar",
- "HexInteger",
- "DecimalInteger",
- "OctalInteger",
- "HexLetter",
- "HexDigit",
- "Digit",
- "NonZeroDigit",
- "NonZeroOctDigit",
- "OctDigit",
- "ZeroDigit",
- "ExponentDecimalReal",
- "RegularDecimalReal",
- "UNION",
- "ALL",
- "OPTIONAL",
- "MATCH",
- "UNWIND",
- "AS",
- "MERGE",
- "ON",
- "CREATE",
- "SET",
- "DETACH",
- "DELETE",
- "REMOVE",
- "WITH",
- "DISTINCT",
- "RETURN",
- "ORDER",
- "BY",
- "L_SKIP",
- "LIMIT",
- "ASCENDING",
- "ASC",
- "DESCENDING",
- "DESC",
- "WHERE",
- "OR",
- "XOR",
- "AND",
- "NOT",
- "IN",
- "STARTS",
- "ENDS",
- "CONTAINS",
- "IS",
- "CYPHERNULL",
- "COUNT",
- "FILTER",
- "EXTRACT",
- "ANY",
- "NONE",
- "SINGLE",
- "TRUE",
- "FALSE",
- "UnescapedSymbolicName",
- "IdentifierStart",
- "IdentifierPart",
- "EscapedSymbolicName",
- "SP",
- "WHITESPACE",
- "Comment",
- "L_0X",
- "FF",
- "EscapedSymbolicName_0",
- "RS",
- "ID_Continue",
- "Comment_1",
- "StringLiteral_1",
- "Comment_3",
- "Comment_2",
- "GS",
- "FS",
- "CR",
- "Sc",
- "SPACE",
- "TAB",
- "StringLiteral_0",
- "LF",
- "VT",
- "US",
- "ID_Start"};
+std::vector<std::string> CypherLexer::_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", "StringLiteral",
+ "EscapedChar", "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter",
+ "HexDigit", "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", "ZeroDigit",
+ "ExponentDecimalReal", "RegularDecimalReal", "UNION", "ALL", "OPTIONAL",
+ "MATCH", "UNWIND", "AS", "MERGE", "ON", "CREATE", "SET", "DETACH", "DELETE",
+ "REMOVE", "WITH", "DISTINCT", "RETURN", "ORDER", "BY", "L_SKIP", "LIMIT",
+ "ASCENDING", "ASC", "DESCENDING", "DESC", "WHERE", "OR", "XOR", "AND",
+ "NOT", "IN", "STARTS", "ENDS", "CONTAINS", "IS", "CYPHERNULL", "COUNT",
+ "FILTER", "EXTRACT", "ANY", "NONE", "SINGLE", "TRUE", "FALSE", "UnescapedSymbolicName",
+ "IdentifierStart", "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE",
+ "Comment", "FF", "EscapedSymbolicName_0", "RS", "ID_Continue", "Comment_1",
+ "StringLiteral_1", "Comment_3", "Comment_2", "GS", "FS", "CR", "Sc", "SPACE",
+ "TAB", "StringLiteral_0", "LF", "VT", "US", "ID_Start"
+};
-std::vector<std::string> CypherLexer::_modeNames = {"DEFAULT_MODE"};
+std::vector<std::string> CypherLexer::_modeNames = {
+ "DEFAULT_MODE"
+};
std::vector<std::string> CypherLexer::_literalNames = {
- "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['",
- "'?'", "']'", "':'", "'|'", "'..'", "'+'", "'-'", "'/'", "'%'",
- "'^'", "'=~'", "'<>'", "'!='", "'<'", "'>'", "'<='", "'>='", "'.'",
- "'!'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", "'﹤'", "'＜'", "'⟩'",
- "'〉'", "'﹥'", "'＞'", "''", "'‐'", "'‑'", "'‒'", "'–'", "'—'",
- "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "",
- "", "", "", "", "", "", "", "'0'"};
+ "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'",
+ "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='",
+ "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'",
+ "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "''", "'‐'", "'‑'", "'‒'",
+ "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "",
+ "", "", "", "", "", "'0'"
+};
-std::vector<std::string> CypherLexer::_symbolicNames = {"",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "StringLiteral",
- "EscapedChar",
- "HexInteger",
- "DecimalInteger",
- "OctalInteger",
- "HexLetter",
- "HexDigit",
- "Digit",
- "NonZeroDigit",
- "NonZeroOctDigit",
- "OctDigit",
- "ZeroDigit",
- "ExponentDecimalReal",
- "RegularDecimalReal",
- "UNION",
- "ALL",
- "OPTIONAL",
- "MATCH",
- "UNWIND",
- "AS",
- "MERGE",
- "ON",
- "CREATE",
- "SET",
- "DETACH",
- "DELETE",
- "REMOVE",
- "WITH",
- "DISTINCT",
- "RETURN",
- "ORDER",
- "BY",
- "L_SKIP",
- "LIMIT",
- "ASCENDING",
- "ASC",
- "DESCENDING",
- "DESC",
- "WHERE",
- "OR",
- "XOR",
- "AND",
- "NOT",
- "IN",
- "STARTS",
- "ENDS",
- "CONTAINS",
- "IS",
- "CYPHERNULL",
- "COUNT",
- "FILTER",
- "EXTRACT",
- "ANY",
- "NONE",
- "SINGLE",
- "TRUE",
- "FALSE",
- "UnescapedSymbolicName",
- "IdentifierStart",
- "IdentifierPart",
- "EscapedSymbolicName",
- "SP",
- "WHITESPACE",
- "Comment",
- "L_0X"};
+std::vector<std::string> CypherLexer::_symbolicNames = {
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "", "", "", "", "", "StringLiteral", "EscapedChar",
+ "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter", "HexDigit",
+ "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", "ZeroDigit", "ExponentDecimalReal",
+ "RegularDecimalReal", "UNION", "ALL", "OPTIONAL", "MATCH", "UNWIND", "AS",
+ "MERGE", "ON", "CREATE", "SET", "DETACH", "DELETE", "REMOVE", "WITH",
+ "DISTINCT", "RETURN", "ORDER", "BY", "L_SKIP", "LIMIT", "ASCENDING", "ASC",
+ "DESCENDING", "DESC", "WHERE", "OR", "XOR", "AND", "NOT", "IN", "STARTS",
+ "ENDS", "CONTAINS", "IS", "CYPHERNULL", "COUNT", "FILTER", "EXTRACT",
+ "ANY", "NONE", "SINGLE", "TRUE", "FALSE", "UnescapedSymbolicName", "IdentifierStart",
+ "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE", "Comment"
+};
dfa::Vocabulary CypherLexer::_vocabulary(_literalNames, _symbolicNames);
std::vector<std::string> CypherLexer::_tokenNames;
CypherLexer::Initializer::Initializer() {
- // This code could be in a static initializer lambda, but VS doesn't allow
- // access to private class members from there.
- for (size_t i = 0; i < _symbolicNames.size(); ++i) {
- std::string name = _vocabulary.getLiteralName(i);
- if (name.empty()) {
- name = _vocabulary.getSymbolicName(i);
- }
+ // This code could be in a static initializer lambda, but VS doesn't allow access to private class members from there.
+ for (size_t i = 0; i < _symbolicNames.size(); ++i) {
+ std::string name = _vocabulary.getLiteralName(i);
+ if (name.empty()) {
+ name = _vocabulary.getSymbolicName(i);
+ }
- if (name.empty()) {
- _tokenNames.push_back("<INVALID>");
- } else {
+ if (name.empty()) {
+ _tokenNames.push_back("<INVALID>");
+ } else {
_tokenNames.push_back(name);
}
- }
+ }
_serializedATN = {
- 0x3, 0x430, 0xd6d1, 0x8206, 0xad2d, 0x4417, 0xaef1, 0x8d80, 0xaadd,
- 0x2, 0x74, 0x363, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2,
- 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9, 0x4, 0x4,
- 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7,
- 0x9, 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9,
- 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 0x9, 0xb,
- 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4,
- 0xe, 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10,
- 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, 0x12, 0x9,
- 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14,
- 0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4,
- 0x17, 0x9, 0x17, 0x4, 0x18, 0x9, 0x18, 0x4, 0x19,
- 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9,
- 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d,
- 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4,
- 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22,
- 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9,
- 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, 0x9, 0x26,
- 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4,
- 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b,
- 0x9, 0x2b, 0x4, 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9,
- 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, 0x9, 0x2f,
- 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4,
- 0x32, 0x9, 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34,
- 0x9, 0x34, 0x4, 0x35, 0x9, 0x35, 0x4, 0x36, 0x9,
- 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38,
- 0x4, 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4,
- 0x3b, 0x9, 0x3b, 0x4, 0x3c, 0x9, 0x3c, 0x4, 0x3d,
- 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9,
- 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41,
- 0x4, 0x42, 0x9, 0x42, 0x4, 0x43, 0x9, 0x43, 0x4,
- 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4, 0x46,
- 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9,
- 0x48, 0x4, 0x49, 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a,
- 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9, 0x4c, 0x4,
- 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f,
- 0x9, 0x4f, 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9,
- 0x51, 0x4, 0x52, 0x9, 0x52, 0x4, 0x53, 0x9, 0x53,
- 0x4, 0x54, 0x9, 0x54, 0x4, 0x55, 0x9, 0x55, 0x4,
- 0x56, 0x9, 0x56, 0x4, 0x57, 0x9, 0x57, 0x4, 0x58,
- 0x9, 0x58, 0x4, 0x59, 0x9, 0x59, 0x4, 0x5a, 0x9,
- 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c, 0x9, 0x5c,
- 0x4, 0x5d, 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4,
- 0x5f, 0x9, 0x5f, 0x4, 0x60, 0x9, 0x60, 0x4, 0x61,
- 0x9, 0x61, 0x4, 0x62, 0x9, 0x62, 0x4, 0x63, 0x9,
- 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65,
- 0x4, 0x66, 0x9, 0x66, 0x4, 0x67, 0x9, 0x67, 0x4,
- 0x68, 0x9, 0x68, 0x4, 0x69, 0x9, 0x69, 0x4, 0x6a,
- 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, 0x9,
- 0x6c, 0x4, 0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e,
- 0x4, 0x6f, 0x9, 0x6f, 0x4, 0x70, 0x9, 0x70, 0x4,
- 0x71, 0x9, 0x71, 0x4, 0x72, 0x9, 0x72, 0x4, 0x73,
- 0x9, 0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, 0x9,
- 0x75, 0x4, 0x76, 0x9, 0x76, 0x4, 0x77, 0x9, 0x77,
- 0x4, 0x78, 0x9, 0x78, 0x4, 0x79, 0x9, 0x79, 0x4,
- 0x7a, 0x9, 0x7a, 0x4, 0x7b, 0x9, 0x7b, 0x4, 0x7c,
- 0x9, 0x7c, 0x4, 0x7d, 0x9, 0x7d, 0x4, 0x7e, 0x9,
- 0x7e, 0x4, 0x7f, 0x9, 0x7f, 0x4, 0x80, 0x9, 0x80,
- 0x4, 0x81, 0x9, 0x81, 0x4, 0x82, 0x9, 0x82, 0x4,
- 0x83, 0x9, 0x83, 0x4, 0x84, 0x9, 0x84, 0x4, 0x85,
- 0x9, 0x85, 0x4, 0x86, 0x9, 0x86, 0x3, 0x2, 0x3,
- 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4,
- 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3,
- 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8,
- 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3,
- 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd,
- 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3,
- 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11,
- 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3,
- 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15,
- 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3,
- 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18,
- 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3,
- 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c,
- 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3,
- 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20,
- 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3,
- 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25,
- 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, 0x3,
- 0x27, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, 0x3, 0x29,
- 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3,
- 0x2c, 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e,
- 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x30, 0x3,
- 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x32, 0x3, 0x32,
- 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x7, 0x33, 0x17a,
- 0xa, 0x33, 0xc, 0x33, 0xe, 0x33, 0x17d, 0xb, 0x33,
- 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x7,
- 0x33, 0x183, 0xa, 0x33, 0xc, 0x33, 0xe, 0x33, 0x186,
- 0xb, 0x33, 0x3, 0x33, 0x5, 0x33, 0x189, 0xa, 0x33,
- 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3,
- 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34,
- 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3,
- 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34,
- 0x5, 0x34, 0x19d, 0xa, 0x34, 0x3, 0x35, 0x3, 0x35,
- 0x6, 0x35, 0x1a1, 0xa, 0x35, 0xd, 0x35, 0xe, 0x35,
- 0x1a2, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x7, 0x36,
- 0x1a8, 0xa, 0x36, 0xc, 0x36, 0xe, 0x36, 0x1ab, 0xb,
- 0x36, 0x5, 0x36, 0x1ad, 0xa, 0x36, 0x3, 0x37, 0x3,
- 0x37, 0x6, 0x37, 0x1b1, 0xa, 0x37, 0xd, 0x37, 0xe,
- 0x37, 0x1b2, 0x3, 0x38, 0x5, 0x38, 0x1b6, 0xa, 0x38,
- 0x3, 0x39, 0x3, 0x39, 0x5, 0x39, 0x1ba, 0xa, 0x39,
- 0x3, 0x3a, 0x3, 0x3a, 0x5, 0x3a, 0x1be, 0xa, 0x3a,
- 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x1c2, 0xa, 0x3b,
- 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x5,
- 0x3d, 0x1c8, 0xa, 0x3d, 0x3, 0x3e, 0x3, 0x3e, 0x3,
- 0x3f, 0x6, 0x3f, 0x1cd, 0xa, 0x3f, 0xd, 0x3f, 0xe,
- 0x3f, 0x1ce, 0x3, 0x3f, 0x6, 0x3f, 0x1d2, 0xa, 0x3f,
- 0xd, 0x3f, 0xe, 0x3f, 0x1d3, 0x3, 0x3f, 0x3, 0x3f,
- 0x6, 0x3f, 0x1d8, 0xa, 0x3f, 0xd, 0x3f, 0xe, 0x3f,
- 0x1d9, 0x3, 0x3f, 0x3, 0x3f, 0x6, 0x3f, 0x1de, 0xa,
- 0x3f, 0xd, 0x3f, 0xe, 0x3f, 0x1df, 0x5, 0x3f, 0x1e2,
- 0xa, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x1e5, 0xa, 0x3f,
- 0x3, 0x3f, 0x5, 0x3f, 0x1e8, 0xa, 0x3f, 0x3, 0x3f,
- 0x6, 0x3f, 0x1eb, 0xa, 0x3f, 0xd, 0x3f, 0xe, 0x3f,
- 0x1ec, 0x3, 0x40, 0x7, 0x40, 0x1f0, 0xa, 0x40, 0xc,
- 0x40, 0xe, 0x40, 0x1f3, 0xb, 0x40, 0x3, 0x40, 0x3,
- 0x40, 0x6, 0x40, 0x1f7, 0xa, 0x40, 0xd, 0x40, 0xe,
- 0x40, 0x1f8, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3,
- 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42,
- 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, 0x3,
- 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43,
- 0x3, 0x43, 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3,
- 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x45,
- 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3,
- 0x45, 0x3, 0x45, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46,
- 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3,
- 0x47, 0x3, 0x47, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48,
- 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3,
- 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x4a, 0x3, 0x4a,
- 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b, 0x3, 0x4b, 0x3,
- 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b,
- 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4c, 0x3,
- 0x4c, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d,
- 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3,
- 0x4d, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e,
- 0x3, 0x4e, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3,
- 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f,
- 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3,
- 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x51,
- 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3,
- 0x51, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x53,
- 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3,
- 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54,
- 0x3, 0x54, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3,
- 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55,
- 0x3, 0x55, 0x3, 0x55, 0x3, 0x56, 0x3, 0x56, 0x3,
- 0x56, 0x3, 0x56, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57,
- 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, 0x3,
- 0x57, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, 0x3, 0x58,
- 0x3, 0x58, 0x3, 0x58, 0x3, 0x58, 0x3, 0x58, 0x3,
- 0x59, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59,
- 0x3, 0x59, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3,
- 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5c,
- 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5d, 0x3,
- 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5e, 0x3, 0x5e,
- 0x3, 0x5e, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3,
- 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x60,
- 0x3, 0x60, 0x3, 0x60, 0x3, 0x60, 0x3, 0x60, 0x3,
- 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x61,
- 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3,
- 0x62, 0x3, 0x62, 0x3, 0x62, 0x3, 0x63, 0x3, 0x63,
- 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x3, 0x64, 0x3,
- 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64,
- 0x3, 0x65, 0x3, 0x65, 0x3, 0x65, 0x3, 0x65, 0x3,
- 0x65, 0x3, 0x65, 0x3, 0x65, 0x3, 0x66, 0x3, 0x66,
- 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3,
- 0x66, 0x3, 0x66, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67,
- 0x3, 0x67, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3,
- 0x68, 0x3, 0x68, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69,
- 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3,
- 0x6a, 0x3, 0x6a, 0x3, 0x6a, 0x3, 0x6a, 0x3, 0x6a,
- 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6b, 0x3,
- 0x6b, 0x3, 0x6b, 0x3, 0x6c, 0x3, 0x6c, 0x7, 0x6c,
- 0x2f5, 0xa, 0x6c, 0xc, 0x6c, 0xe, 0x6c, 0x2f8, 0xb,
- 0x6c, 0x3, 0x6d, 0x3, 0x6d, 0x5, 0x6d, 0x2fc, 0xa,
- 0x6d, 0x3, 0x6e, 0x3, 0x6e, 0x5, 0x6e, 0x300, 0xa,
- 0x6e, 0x3, 0x6f, 0x3, 0x6f, 0x7, 0x6f, 0x304, 0xa,
- 0x6f, 0xc, 0x6f, 0xe, 0x6f, 0x307, 0xb, 0x6f, 0x3,
- 0x6f, 0x6, 0x6f, 0x30a, 0xa, 0x6f, 0xd, 0x6f, 0xe,
- 0x6f, 0x30b, 0x3, 0x70, 0x6, 0x70, 0x30f, 0xa, 0x70,
- 0xd, 0x70, 0xe, 0x70, 0x310, 0x3, 0x71, 0x3, 0x71,
- 0x3, 0x71, 0x3, 0x71, 0x3, 0x71, 0x3, 0x71, 0x3,
- 0x71, 0x3, 0x71, 0x3, 0x71, 0x3, 0x71, 0x3, 0x71,
- 0x3, 0x71, 0x5, 0x71, 0x31f, 0xa, 0x71, 0x3, 0x72,
- 0x3, 0x72, 0x3, 0x72, 0x3, 0x72, 0x3, 0x72, 0x3,
- 0x72, 0x7, 0x72, 0x327, 0xa, 0x72, 0xc, 0x72, 0xe,
- 0x72, 0x32a, 0xb, 0x72, 0x3, 0x72, 0x3, 0x72, 0x3,
- 0x72, 0x3, 0x72, 0x3, 0x72, 0x3, 0x72, 0x3, 0x72,
- 0x5, 0x72, 0x333, 0xa, 0x72, 0x3, 0x72, 0x3, 0x72,
- 0x5, 0x72, 0x337, 0xa, 0x72, 0x5, 0x72, 0x339, 0xa,
- 0x72, 0x3, 0x73, 0x3, 0x73, 0x3, 0x73, 0x3, 0x74,
- 0x3, 0x74, 0x3, 0x75, 0x3, 0x75, 0x3, 0x76, 0x3,
- 0x76, 0x3, 0x77, 0x3, 0x77, 0x3, 0x78, 0x3, 0x78,
- 0x3, 0x79, 0x3, 0x79, 0x3, 0x7a, 0x3, 0x7a, 0x3,
- 0x7b, 0x3, 0x7b, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7d,
- 0x3, 0x7d, 0x3, 0x7e, 0x3, 0x7e, 0x3, 0x7f, 0x3,
- 0x7f, 0x3, 0x80, 0x3, 0x80, 0x3, 0x81, 0x3, 0x81,
- 0x3, 0x82, 0x3, 0x82, 0x3, 0x83, 0x3, 0x83, 0x3,
- 0x84, 0x3, 0x84, 0x3, 0x85, 0x3, 0x85, 0x3, 0x86,
- 0x3, 0x86, 0x2, 0x2, 0x87, 0x3, 0x3, 0x5, 0x4,
- 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf,
- 0x9, 0x11, 0xa, 0x13, 0xb, 0x15, 0xc, 0x17, 0xd,
- 0x19, 0xe, 0x1b, 0xf, 0x1d, 0x10, 0x1f, 0x11, 0x21,
- 0x12, 0x23, 0x13, 0x25, 0x14, 0x27, 0x15, 0x29, 0x16,
- 0x2b, 0x17, 0x2d, 0x18, 0x2f, 0x19, 0x31, 0x1a, 0x33,
- 0x1b, 0x35, 0x1c, 0x37, 0x1d, 0x39, 0x1e, 0x3b, 0x1f,
- 0x3d, 0x20, 0x3f, 0x21, 0x41, 0x22, 0x43, 0x23, 0x45,
- 0x24, 0x47, 0x25, 0x49, 0x26, 0x4b, 0x27, 0x4d, 0x28,
- 0x4f, 0x29, 0x51, 0x2a, 0x53, 0x2b, 0x55, 0x2c, 0x57,
- 0x2d, 0x59, 0x2e, 0x5b, 0x2f, 0x5d, 0x30, 0x5f, 0x31,
- 0x61, 0x32, 0x63, 0x33, 0x65, 0x34, 0x67, 0x35, 0x69,
- 0x36, 0x6b, 0x37, 0x6d, 0x38, 0x6f, 0x39, 0x71, 0x3a,
- 0x73, 0x3b, 0x75, 0x3c, 0x77, 0x3d, 0x79, 0x3e, 0x7b,
- 0x3f, 0x7d, 0x40, 0x7f, 0x41, 0x81, 0x42, 0x83, 0x43,
- 0x85, 0x44, 0x87, 0x45, 0x89, 0x46, 0x8b, 0x47, 0x8d,
- 0x48, 0x8f, 0x49, 0x91, 0x4a, 0x93, 0x4b, 0x95, 0x4c,
- 0x97, 0x4d, 0x99, 0x4e, 0x9b, 0x4f, 0x9d, 0x50, 0x9f,
- 0x51, 0xa1, 0x52, 0xa3, 0x53, 0xa5, 0x54, 0xa7, 0x55,
- 0xa9, 0x56, 0xab, 0x57, 0xad, 0x58, 0xaf, 0x59, 0xb1,
- 0x5a, 0xb3, 0x5b, 0xb5, 0x5c, 0xb7, 0x5d, 0xb9, 0x5e,
- 0xbb, 0x5f, 0xbd, 0x60, 0xbf, 0x61, 0xc1, 0x62, 0xc3,
- 0x63, 0xc5, 0x64, 0xc7, 0x65, 0xc9, 0x66, 0xcb, 0x67,
- 0xcd, 0x68, 0xcf, 0x69, 0xd1, 0x6a, 0xd3, 0x6b, 0xd5,
- 0x6c, 0xd7, 0x6d, 0xd9, 0x6e, 0xdb, 0x6f, 0xdd, 0x70,
- 0xdf, 0x71, 0xe1, 0x72, 0xe3, 0x73, 0xe5, 0x74, 0xe7,
- 0x2, 0xe9, 0x2, 0xeb, 0x2, 0xed, 0x2, 0xef, 0x2,
- 0xf1, 0x2, 0xf3, 0x2, 0xf5, 0x2, 0xf7, 0x2, 0xf9,
- 0x2, 0xfb, 0x2, 0xfd, 0x2, 0xff, 0x2, 0x101, 0x2,
- 0x103, 0x2, 0x105, 0x2, 0x107, 0x2, 0x109, 0x2, 0x10b,
- 0x2, 0x3, 0x2, 0x30, 0x11, 0x2, 0x24, 0x24, 0x27,
- 0x27, 0x29, 0x29, 0x44, 0x44, 0x48, 0x48, 0x50, 0x50,
- 0x54, 0x54, 0x56, 0x56, 0x5e, 0x5e, 0x61, 0x61, 0x64,
- 0x64, 0x68, 0x68, 0x70, 0x70, 0x74, 0x74, 0x76, 0x76,
- 0x4, 0x2, 0x57, 0x57, 0x77, 0x77, 0x4, 0x2, 0x43,
- 0x48, 0x63, 0x68, 0x4, 0x2, 0x47, 0x47, 0x67, 0x67,
- 0x4, 0x2, 0x50, 0x50, 0x70, 0x70, 0x4, 0x2, 0x4b,
- 0x4b, 0x6b, 0x6b, 0x4, 0x2, 0x51, 0x51, 0x71, 0x71,
- 0x4, 0x2, 0x43, 0x43, 0x63, 0x63, 0x4, 0x2, 0x4e,
- 0x4e, 0x6e, 0x6e, 0x4, 0x2, 0x52, 0x52, 0x72, 0x72,
- 0x4, 0x2, 0x56, 0x56, 0x76, 0x76, 0x4, 0x2, 0x4f,
- 0x4f, 0x6f, 0x6f, 0x4, 0x2, 0x45, 0x45, 0x65, 0x65,
- 0x4, 0x2, 0x4a, 0x4a, 0x6a, 0x6a, 0x4, 0x2, 0x59,
- 0x59, 0x79, 0x79, 0x4, 0x2, 0x46, 0x46, 0x66, 0x66,
- 0x4, 0x2, 0x55, 0x55, 0x75, 0x75, 0x4, 0x2, 0x54,
- 0x54, 0x74, 0x74, 0x4, 0x2, 0x49, 0x49, 0x69, 0x69,
- 0x4, 0x2, 0x58, 0x58, 0x78, 0x78, 0x4, 0x2, 0x44,
- 0x44, 0x64, 0x64, 0x4, 0x2, 0x5b, 0x5b, 0x7b, 0x7b,
- 0x4, 0x2, 0x4d, 0x4d, 0x6d, 0x6d, 0x4, 0x2, 0x5a,
- 0x5a, 0x7a, 0x7a, 0x4, 0x2, 0x48, 0x48, 0x68, 0x68,
- 0x8, 0x2, 0x61, 0x61, 0x2041, 0x2042, 0x2056, 0x2056, 0xfe35,
- 0xfe36, 0xfe4f, 0xfe51, 0xff41, 0xff41, 0xa, 0x2, 0xa2, 0xa2,
- 0x1682, 0x1682, 0x1810, 0x1810, 0x2002, 0x200c, 0x202a, 0x202b, 0x2031,
- 0x2031, 0x2061, 0x2061, 0x3002, 0x3002, 0x3, 0x2, 0xe, 0xe,
- 0x4, 0x2, 0x2, 0x61, 0x63, 0x1, 0x3, 0x2, 0x20,
- 0x20, 0x1af, 0x2, 0x32, 0x3b, 0x43, 0x5c, 0x61, 0x61,
- 0x63, 0x7c, 0xac, 0xac, 0xb7, 0xb7, 0xb9, 0xb9, 0xbc,
- 0xbc, 0xc2, 0xd8, 0xda, 0xf8, 0xfa, 0x2c3, 0x2c8, 0x2d3,
- 0x2e2, 0x2e6, 0x2ee, 0x2ee, 0x2f0, 0x2f0, 0x302, 0x376, 0x378,
- 0x379, 0x37c, 0x37f, 0x388, 0x38c, 0x38e, 0x38e, 0x390, 0x3a3,
- 0x3a5, 0x3f7, 0x3f9, 0x483, 0x485, 0x489, 0x48c, 0x529, 0x533,
- 0x558, 0x55b, 0x55b, 0x563, 0x589, 0x593, 0x5bf, 0x5c1, 0x5c1,
- 0x5c3, 0x5c4, 0x5c6, 0x5c7, 0x5c9, 0x5c9, 0x5d2, 0x5ec, 0x5f2,
- 0x5f4, 0x612, 0x61c, 0x622, 0x66b, 0x670, 0x6d5, 0x6d7, 0x6de,
- 0x6e1, 0x6ea, 0x6ec, 0x6fe, 0x701, 0x701, 0x712, 0x74c, 0x74f,
- 0x7b3, 0x7c2, 0x7f7, 0x7fc, 0x7fc, 0x802, 0x82f, 0x842, 0x85d,
- 0x8a2, 0x8a2, 0x8a4, 0x8ae, 0x8e6, 0x900, 0x902, 0x965, 0x968,
- 0x971, 0x973, 0x979, 0x97b, 0x981, 0x983, 0x985, 0x987, 0x98e,
- 0x991, 0x992, 0x995, 0x9aa, 0x9ac, 0x9b2, 0x9b4, 0x9b4, 0x9b8,
- 0x9bb, 0x9be, 0x9c6, 0x9c9, 0x9ca, 0x9cd, 0x9d0, 0x9d9, 0x9d9,
- 0x9de, 0x9df, 0x9e1, 0x9e5, 0x9e8, 0x9f3, 0xa03, 0xa05, 0xa07,
- 0xa0c, 0xa11, 0xa12, 0xa15, 0xa2a, 0xa2c, 0xa32, 0xa34, 0xa35,
- 0xa37, 0xa38, 0xa3a, 0xa3b, 0xa3e, 0xa3e, 0xa40, 0xa44, 0xa49,
- 0xa4a, 0xa4d, 0xa4f, 0xa53, 0xa53, 0xa5b, 0xa5e, 0xa60, 0xa60,
- 0xa68, 0xa77, 0xa83, 0xa85, 0xa87, 0xa8f, 0xa91, 0xa93, 0xa95,
- 0xaaa, 0xaac, 0xab2, 0xab4, 0xab5, 0xab7, 0xabb, 0xabe, 0xac7,
- 0xac9, 0xacb, 0xacd, 0xacf, 0xad2, 0xad2, 0xae2, 0xae5, 0xae8,
- 0xaf1, 0xb03, 0xb05, 0xb07, 0xb0e, 0xb11, 0xb12, 0xb15, 0xb2a,
- 0xb2c, 0xb32, 0xb34, 0xb35, 0xb37, 0xb3b, 0xb3e, 0xb46, 0xb49,
- 0xb4a, 0xb4d, 0xb4f, 0xb58, 0xb59, 0xb5e, 0xb5f, 0xb61, 0xb65,
- 0xb68, 0xb71, 0xb73, 0xb73, 0xb84, 0xb85, 0xb87, 0xb8c, 0xb90,
- 0xb92, 0xb94, 0xb97, 0xb9b, 0xb9c, 0xb9e, 0xb9e, 0xba0, 0xba1,
- 0xba5, 0xba6, 0xbaa, 0xbac, 0xbb0, 0xbbb, 0xbc0, 0xbc4, 0xbc8,
- 0xbca, 0xbcc, 0xbcf, 0xbd2, 0xbd2, 0xbd9, 0xbd9, 0xbe8, 0xbf1,
- 0xc03, 0xc05, 0xc07, 0xc0e, 0xc10, 0xc12, 0xc14, 0xc2a, 0xc2c,
- 0xc35, 0xc37, 0xc3b, 0xc3f, 0xc46, 0xc48, 0xc4a, 0xc4c, 0xc4f,
- 0xc57, 0xc58, 0xc5a, 0xc5b, 0xc62, 0xc65, 0xc68, 0xc71, 0xc84,
- 0xc85, 0xc87, 0xc8e, 0xc90, 0xc92, 0xc94, 0xcaa, 0xcac, 0xcb5,
- 0xcb7, 0xcbb, 0xcbe, 0xcc6, 0xcc8, 0xcca, 0xccc, 0xccf, 0xcd7,
- 0xcd8, 0xce0, 0xce0, 0xce2, 0xce5, 0xce8, 0xcf1, 0xcf3, 0xcf4,
- 0xd04, 0xd05, 0xd07, 0xd0e, 0xd10, 0xd12, 0xd14, 0xd3c, 0xd3f,
- 0xd46, 0xd48, 0xd4a, 0xd4c, 0xd50, 0xd59, 0xd59, 0xd62, 0xd65,
- 0xd68, 0xd71, 0xd7c, 0xd81, 0xd84, 0xd85, 0xd87, 0xd98, 0xd9c,
- 0xdb3, 0xdb5, 0xdbd, 0xdbf, 0xdbf, 0xdc2, 0xdc8, 0xdcc, 0xdcc,
- 0xdd1, 0xdd6, 0xdd8, 0xdd8, 0xdda, 0xde1, 0xdf4, 0xdf5, 0xe03,
- 0xe3c, 0xe42, 0xe50, 0xe52, 0xe5b, 0xe83, 0xe84, 0xe86, 0xe86,
- 0xe89, 0xe8a, 0xe8c, 0xe8c, 0xe8f, 0xe8f, 0xe96, 0xe99, 0xe9b,
- 0xea1, 0xea3, 0xea5, 0xea7, 0xea7, 0xea9, 0xea9, 0xeac, 0xead,
- 0xeaf, 0xebb, 0xebd, 0xebf, 0xec2, 0xec6, 0xec8, 0xec8, 0xeca,
- 0xecf, 0xed2, 0xedb, 0xede, 0xee1, 0xf02, 0xf02, 0xf1a, 0xf1b,
- 0xf22, 0xf2b, 0xf37, 0xf37, 0xf39, 0xf39, 0xf3b, 0xf3b, 0xf40,
- 0xf49, 0xf4b, 0xf6e, 0xf73, 0xf86, 0xf88, 0xf99, 0xf9b, 0xfbe,
- 0xfc8, 0xfc8, 0x1002, 0x104b, 0x1052, 0x109f, 0x10a2, 0x10c7, 0x10c9,
- 0x10c9, 0x10cf, 0x10cf, 0x10d2, 0x10fc, 0x10fe, 0x124a, 0x124c, 0x124f,
- 0x1252, 0x1258, 0x125a, 0x125a, 0x125c, 0x125f, 0x1262, 0x128a, 0x128c,
- 0x128f, 0x1292, 0x12b2, 0x12b4, 0x12b7, 0x12ba, 0x12c0, 0x12c2, 0x12c2,
- 0x12c4, 0x12c7, 0x12ca, 0x12d8, 0x12da, 0x1312, 0x1314, 0x1317, 0x131a,
- 0x135c, 0x135f, 0x1361, 0x136b, 0x1373, 0x1382, 0x1391, 0x13a2, 0x13f6,
- 0x1403, 0x166e, 0x1671, 0x1681, 0x1683, 0x169c, 0x16a2, 0x16ec, 0x16f0,
- 0x16f2, 0x1702, 0x170e, 0x1710, 0x1716, 0x1722, 0x1736, 0x1742, 0x1755,
- 0x1762, 0x176e, 0x1770, 0x1772, 0x1774, 0x1775, 0x1782, 0x17d5, 0x17d9,
- 0x17d9, 0x17de, 0x17df, 0x17e2, 0x17eb, 0x180d, 0x180f, 0x1812, 0x181b,
- 0x1822, 0x1879, 0x1882, 0x18ac, 0x18b2, 0x18f7, 0x1902, 0x191e, 0x1922,
- 0x192d, 0x1932, 0x193d, 0x1948, 0x196f, 0x1972, 0x1976, 0x1982, 0x19ad,
- 0x19b2, 0x19cb, 0x19d2, 0x19dc, 0x1a02, 0x1a1d, 0x1a22, 0x1a60, 0x1a62,
- 0x1a7e, 0x1a81, 0x1a8b, 0x1a92, 0x1a9b, 0x1aa9, 0x1aa9, 0x1b02, 0x1b4d,
- 0x1b52, 0x1b5b, 0x1b6d, 0x1b75, 0x1b82, 0x1bf5, 0x1c02, 0x1c39, 0x1c42,
- 0x1c4b, 0x1c4f, 0x1c7f, 0x1cd2, 0x1cd4, 0x1cd6, 0x1cf8, 0x1d02, 0x1de8,
- 0x1dfe, 0x1f17, 0x1f1a, 0x1f1f, 0x1f22, 0x1f47, 0x1f4a, 0x1f4f, 0x1f52,
- 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f5f, 0x1f61, 0x1f7f,
- 0x1f82, 0x1fb6, 0x1fb8, 0x1fbe, 0x1fc0, 0x1fc0, 0x1fc4, 0x1fc6, 0x1fc8,
- 0x1fce, 0x1fd2, 0x1fd5, 0x1fd8, 0x1fdd, 0x1fe2, 0x1fee, 0x1ff4, 0x1ff6,
- 0x1ff8, 0x1ffe, 0x2041, 0x2042, 0x2056, 0x2056, 0x2073, 0x2073, 0x2081,
- 0x2081, 0x2092, 0x209e, 0x20d2, 0x20de, 0x20e3, 0x20e3, 0x20e7, 0x20f2,
- 0x2104, 0x2104, 0x2109, 0x2109, 0x210c, 0x2115, 0x2117, 0x2117, 0x211a,
- 0x211f, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212a, 0x212c, 0x213b,
- 0x213e, 0x2141, 0x2147, 0x214b, 0x2150, 0x2150, 0x2162, 0x218a, 0x2c02,
- 0x2c30, 0x2c32, 0x2c60, 0x2c62, 0x2ce6, 0x2ced, 0x2cf5, 0x2d02, 0x2d27,
- 0x2d29, 0x2d29, 0x2d2f, 0x2d2f, 0x2d32, 0x2d69, 0x2d71, 0x2d71, 0x2d81,
- 0x2d98, 0x2da2, 0x2da8, 0x2daa, 0x2db0, 0x2db2, 0x2db8, 0x2dba, 0x2dc0,
- 0x2dc2, 0x2dc8, 0x2dca, 0x2dd0, 0x2dd2, 0x2dd8, 0x2dda, 0x2de0, 0x2de2,
- 0x2e01, 0x3007, 0x3009, 0x3023, 0x3031, 0x3033, 0x3037, 0x303a, 0x303e,
- 0x3043, 0x3098, 0x309b, 0x30a1, 0x30a3, 0x30fc, 0x30fe, 0x3101, 0x3107,
- 0x312f, 0x3133, 0x3190, 0x31a2, 0x31bc, 0x31f2, 0x3201, 0x3402, 0x4db7,
- 0x4e02, 0x9fce, 0xa002, 0xa48e, 0xa4d2, 0xa4ff, 0xa502, 0xa60e, 0xa612,
- 0xa62d, 0xa642, 0xa671, 0xa676, 0xa67f, 0xa681, 0xa699, 0xa6a1, 0xa6f3,
- 0xa719, 0xa721, 0xa724, 0xa78a, 0xa78d, 0xa790, 0xa792, 0xa795, 0xa7a2,
- 0xa7ac, 0xa7fa, 0xa829, 0xa842, 0xa875, 0xa882, 0xa8c6, 0xa8d2, 0xa8db,
- 0xa8e2, 0xa8f9, 0xa8fd, 0xa8fd, 0xa902, 0xa92f, 0xa932, 0xa955, 0xa962,
- 0xa97e, 0xa982, 0xa9c2, 0xa9d1, 0xa9db, 0xaa02, 0xaa38, 0xaa42, 0xaa4f,
- 0xaa52, 0xaa5b, 0xaa62, 0xaa78, 0xaa7c, 0xaa7d, 0xaa82, 0xaac4, 0xaadd,
- 0xaadf, 0xaae2, 0xaaf1, 0xaaf4, 0xaaf8, 0xab03, 0xab08, 0xab0b, 0xab10,
- 0xab13, 0xab18, 0xab22, 0xab28, 0xab2a, 0xab30, 0xabc2, 0xabec, 0xabee,
- 0xabef, 0xabf2, 0xabfb, 0xac02, 0xd7a5, 0xd7b2, 0xd7c8, 0xd7cd, 0xd7fd,
- 0xf902, 0xfa6f, 0xfa72, 0xfadb, 0xfb02, 0xfb08, 0xfb15, 0xfb19, 0xfb1f,
- 0xfb2a, 0xfb2c, 0xfb38, 0xfb3a, 0xfb3e, 0xfb40, 0xfb40, 0xfb42, 0xfb43,
- 0xfb45, 0xfb46, 0xfb48, 0xfbb3, 0xfbd5, 0xfd3f, 0xfd52, 0xfd91, 0xfd94,
- 0xfdc9, 0xfdf2, 0xfdfd, 0xfe02, 0xfe11, 0xfe22, 0xfe28, 0xfe35, 0xfe36,
- 0xfe4f, 0xfe51, 0xfe72, 0xfe76, 0xfe78, 0xfefe, 0xff12, 0xff1b, 0xff23,
- 0xff3c, 0xff41, 0xff41, 0xff43, 0xff5c, 0xff68, 0xffc0, 0xffc4, 0xffc9,
- 0xffcc, 0xffd1, 0xffd4, 0xffd9, 0xffdc, 0xffde, 0x4, 0x2, 0x2,
- 0x2b, 0x2d, 0x1, 0x5, 0x2, 0x2, 0x28, 0x2a, 0x5d,
- 0x5f, 0x1, 0x5, 0x2, 0x2, 0xb, 0xd, 0xe, 0x10,
- 0x1, 0x4, 0x2, 0x2, 0x30, 0x32, 0x1, 0x3, 0x2,
- 0x1f, 0x1f, 0x3, 0x2, 0x1e, 0x1e, 0x3, 0x2, 0xf,
- 0xf, 0x13, 0x2, 0x26, 0x26, 0xa4, 0xa7, 0x591, 0x591,
- 0x60d, 0x60d, 0x9f4, 0x9f5, 0x9fd, 0x9fd, 0xaf3, 0xaf3, 0xbfb,
- 0xbfb, 0xe41, 0xe41, 0x17dd, 0x17dd, 0x20a2, 0x20bc, 0xa83a, 0xa83a,
- 0xfdfe, 0xfdfe, 0xfe6b, 0xfe6b, 0xff06, 0xff06, 0xffe2, 0xffe3, 0xffe7,
- 0xffe8, 0x3, 0x2, 0x22, 0x22, 0x3, 0x2, 0xb, 0xb,
- 0x5, 0x2, 0x2, 0x23, 0x25, 0x5d, 0x5f, 0x1, 0x3,
- 0x2, 0xc, 0xc, 0x3, 0x2, 0xd, 0xd, 0x3, 0x2,
- 0x21, 0x21, 0x174, 0x2, 0x43, 0x5c, 0x63, 0x7c, 0xac,
- 0xac, 0xb7, 0xb7, 0xbc, 0xbc, 0xc2, 0xd8, 0xda, 0xf8,
- 0xfa, 0x2c3, 0x2c8, 0x2d3, 0x2e2, 0x2e6, 0x2ee, 0x2ee, 0x2f0,
- 0x2f0, 0x372, 0x376, 0x378, 0x379, 0x37c, 0x37f, 0x388, 0x388,
- 0x38a, 0x38c, 0x38e, 0x38e, 0x390, 0x3a3, 0x3a5, 0x3f7, 0x3f9,
- 0x483, 0x48c, 0x529, 0x533, 0x558, 0x55b, 0x55b, 0x563, 0x589,
- 0x5d2, 0x5ec, 0x5f2, 0x5f4, 0x622, 0x64c, 0x670, 0x671, 0x673,
- 0x6d5, 0x6d7, 0x6d7, 0x6e7, 0x6e8, 0x6f0, 0x6f1, 0x6fc, 0x6fe,
- 0x701, 0x701, 0x712, 0x712, 0x714, 0x731, 0x74f, 0x7a7, 0x7b3,
- 0x7b3, 0x7cc, 0x7ec, 0x7f6, 0x7f7, 0x7fc, 0x7fc, 0x802, 0x817,
- 0x81c, 0x81c, 0x826, 0x826, 0x82a, 0x82a, 0x842, 0x85a, 0x8a2,
- 0x8a2, 0x8a4, 0x8ae, 0x906, 0x93b, 0x93f, 0x93f, 0x952, 0x952,
- 0x95a, 0x963, 0x973, 0x979, 0x97b, 0x981, 0x987, 0x98e, 0x991,
- 0x992, 0x995, 0x9aa, 0x9ac, 0x9b2, 0x9b4, 0x9b4, 0x9b8, 0x9bb,
- 0x9bf, 0x9bf, 0x9d0, 0x9d0, 0x9de, 0x9df, 0x9e1, 0x9e3, 0x9f2,
- 0x9f3, 0xa07, 0xa0c, 0xa11, 0xa12, 0xa15, 0xa2a, 0xa2c, 0xa32,
- 0xa34, 0xa35, 0xa37, 0xa38, 0xa3a, 0xa3b, 0xa5b, 0xa5e, 0xa60,
- 0xa60, 0xa74, 0xa76, 0xa87, 0xa8f, 0xa91, 0xa93, 0xa95, 0xaaa,
- 0xaac, 0xab2, 0xab4, 0xab5, 0xab7, 0xabb, 0xabf, 0xabf, 0xad2,
- 0xad2, 0xae2, 0xae3, 0xb07, 0xb0e, 0xb11, 0xb12, 0xb15, 0xb2a,
- 0xb2c, 0xb32, 0xb34, 0xb35, 0xb37, 0xb3b, 0xb3f, 0xb3f, 0xb5e,
- 0xb5f, 0xb61, 0xb63, 0xb73, 0xb73, 0xb85, 0xb85, 0xb87, 0xb8c,
- 0xb90, 0xb92, 0xb94, 0xb97, 0xb9b, 0xb9c, 0xb9e, 0xb9e, 0xba0,
- 0xba1, 0xba5, 0xba6, 0xbaa, 0xbac, 0xbb0, 0xbbb, 0xbd2, 0xbd2,
- 0xc07, 0xc0e, 0xc10, 0xc12, 0xc14, 0xc2a, 0xc2c, 0xc35, 0xc37,
- 0xc3b, 0xc3f, 0xc3f, 0xc5a, 0xc5b, 0xc62, 0xc63, 0xc87, 0xc8e,
- 0xc90, 0xc92, 0xc94, 0xcaa, 0xcac, 0xcb5, 0xcb7, 0xcbb, 0xcbf,
- 0xcbf, 0xce0, 0xce0, 0xce2, 0xce3, 0xcf3, 0xcf4, 0xd07, 0xd0e,
- 0xd10, 0xd12, 0xd14, 0xd3c, 0xd3f, 0xd3f, 0xd50, 0xd50, 0xd62,
- 0xd63, 0xd7c, 0xd81, 0xd87, 0xd98, 0xd9c, 0xdb3, 0xdb5, 0xdbd,
- 0xdbf, 0xdbf, 0xdc2, 0xdc8, 0xe03, 0xe32, 0xe34, 0xe35, 0xe42,
- 0xe48, 0xe83, 0xe84, 0xe86, 0xe86, 0xe89, 0xe8a, 0xe8c, 0xe8c,
- 0xe8f, 0xe8f, 0xe96, 0xe99, 0xe9b, 0xea1, 0xea3, 0xea5, 0xea7,
- 0xea7, 0xea9, 0xea9, 0xeac, 0xead, 0xeaf, 0xeb2, 0xeb4, 0xeb5,
- 0xebf, 0xebf, 0xec2, 0xec6, 0xec8, 0xec8, 0xede, 0xee1, 0xf02,
- 0xf02, 0xf42, 0xf49, 0xf4b, 0xf6e, 0xf8a, 0xf8e, 0x1002, 0x102c,
- 0x1041, 0x1041, 0x1052, 0x1057, 0x105c, 0x105f, 0x1063, 0x1063, 0x1067,
- 0x1068, 0x1070, 0x1072, 0x1077, 0x1083, 0x1090, 0x1090, 0x10a2, 0x10c7,
- 0x10c9, 0x10c9, 0x10cf, 0x10cf, 0x10d2, 0x10fc, 0x10fe, 0x124a, 0x124c,
- 0x124f, 0x1252, 0x1258, 0x125a, 0x125a, 0x125c, 0x125f, 0x1262, 0x128a,
- 0x128c, 0x128f, 0x1292, 0x12b2, 0x12b4, 0x12b7, 0x12ba, 0x12c0, 0x12c2,
- 0x12c2, 0x12c4, 0x12c7, 0x12ca, 0x12d8, 0x12da, 0x1312, 0x1314, 0x1317,
- 0x131a, 0x135c, 0x1382, 0x1391, 0x13a2, 0x13f6, 0x1403, 0x166e, 0x1671,
- 0x1681, 0x1683, 0x169c, 0x16a2, 0x16ec, 0x16f0, 0x16f2, 0x1702, 0x170e,
- 0x1710, 0x1713, 0x1722, 0x1733, 0x1742, 0x1753, 0x1762, 0x176e, 0x1770,
- 0x1772, 0x1782, 0x17b5, 0x17d9, 0x17d9, 0x17de, 0x17de, 0x1822, 0x1879,
- 0x1882, 0x18aa, 0x18ac, 0x18ac, 0x18b2, 0x18f7, 0x1902, 0x191e, 0x1952,
- 0x196f, 0x1972, 0x1976, 0x1982, 0x19ad, 0x19c3, 0x19c9, 0x1a02, 0x1a18,
- 0x1a22, 0x1a56, 0x1aa9, 0x1aa9, 0x1b07, 0x1b35, 0x1b47, 0x1b4d, 0x1b85,
- 0x1ba2, 0x1bb0, 0x1bb1, 0x1bbc, 0x1be7, 0x1c02, 0x1c25, 0x1c4f, 0x1c51,
- 0x1c5c, 0x1c7f, 0x1ceb, 0x1cee, 0x1cf0, 0x1cf3, 0x1cf7, 0x1cf8, 0x1d02,
- 0x1dc1, 0x1e02, 0x1f17, 0x1f1a, 0x1f1f, 0x1f22, 0x1f47, 0x1f4a, 0x1f4f,
- 0x1f52, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f5f, 0x1f61,
- 0x1f7f, 0x1f82, 0x1fb6, 0x1fb8, 0x1fbe, 0x1fc0, 0x1fc0, 0x1fc4, 0x1fc6,
- 0x1fc8, 0x1fce, 0x1fd2, 0x1fd5, 0x1fd8, 0x1fdd, 0x1fe2, 0x1fee, 0x1ff4,
- 0x1ff6, 0x1ff8, 0x1ffe, 0x2073, 0x2073, 0x2081, 0x2081, 0x2092, 0x209e,
- 0x2104, 0x2104, 0x2109, 0x2109, 0x210c, 0x2115, 0x2117, 0x2117, 0x211a,
- 0x211f, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212a, 0x212c, 0x213b,
- 0x213e, 0x2141, 0x2147, 0x214b, 0x2150, 0x2150, 0x2162, 0x218a, 0x2c02,
- 0x2c30, 0x2c32, 0x2c60, 0x2c62, 0x2ce6, 0x2ced, 0x2cf0, 0x2cf4, 0x2cf5,
- 0x2d02, 0x2d27, 0x2d29, 0x2d29, 0x2d2f, 0x2d2f, 0x2d32, 0x2d69, 0x2d71,
- 0x2d71, 0x2d82, 0x2d98, 0x2da2, 0x2da8, 0x2daa, 0x2db0, 0x2db2, 0x2db8,
- 0x2dba, 0x2dc0, 0x2dc2, 0x2dc8, 0x2dca, 0x2dd0, 0x2dd2, 0x2dd8, 0x2dda,
- 0x2de0, 0x3007, 0x3009, 0x3023, 0x302b, 0x3033, 0x3037, 0x303a, 0x303e,
- 0x3043, 0x3098, 0x309d, 0x30a1, 0x30a3, 0x30fc, 0x30fe, 0x3101, 0x3107,
- 0x312f, 0x3133, 0x3190, 0x31a2, 0x31bc, 0x31f2, 0x3201, 0x3402, 0x4db7,
- 0x4e02, 0x9fce, 0xa002, 0xa48e, 0xa4d2, 0xa4ff, 0xa502, 0xa60e, 0xa612,
- 0xa621, 0xa62c, 0xa62d, 0xa642, 0xa670, 0xa681, 0xa699, 0xa6a2, 0xa6f1,
- 0xa719, 0xa721, 0xa724, 0xa78a, 0xa78d, 0xa790, 0xa792, 0xa795, 0xa7a2,
- 0xa7ac, 0xa7fa, 0xa803, 0xa805, 0xa807, 0xa809, 0xa80c, 0xa80e, 0xa824,
- 0xa842, 0xa875, 0xa884, 0xa8b5, 0xa8f4, 0xa8f9, 0xa8fd, 0xa8fd, 0xa90c,
- 0xa927, 0xa932, 0xa948, 0xa962, 0xa97e, 0xa986, 0xa9b4, 0xa9d1, 0xa9d1,
- 0xaa02, 0xaa2a, 0xaa42, 0xaa44, 0xaa46, 0xaa4d, 0xaa62, 0xaa78, 0xaa7c,
- 0xaa7c, 0xaa82, 0xaab1, 0xaab3, 0xaab3, 0xaab7, 0xaab8, 0xaabb, 0xaabf,
- 0xaac2, 0xaac2, 0xaac4, 0xaac4, 0xaadd, 0xaadf, 0xaae2, 0xaaec, 0xaaf4,
- 0xaaf6, 0xab03, 0xab08, 0xab0b, 0xab10, 0xab13, 0xab18, 0xab22, 0xab28,
- 0xab2a, 0xab30, 0xabc2, 0xabe4, 0xac02, 0xd7a5, 0xd7b2, 0xd7c8, 0xd7cd,
- 0xd7fd, 0xf902, 0xfa6f, 0xfa72, 0xfadb, 0xfb02, 0xfb08, 0xfb15, 0xfb19,
- 0xfb1f, 0xfb1f, 0xfb21, 0xfb2a, 0xfb2c, 0xfb38, 0xfb3a, 0xfb3e, 0xfb40,
- 0xfb40, 0xfb42, 0xfb43, 0xfb45, 0xfb46, 0xfb48, 0xfbb3, 0xfbd5, 0xfd3f,
- 0xfd52, 0xfd91, 0xfd94, 0xfdc9, 0xfdf2, 0xfdfd, 0xfe72, 0xfe76, 0xfe78,
- 0xfefe, 0xff23, 0xff3c, 0xff43, 0xff5c, 0xff68, 0xffc0, 0xffc4, 0xffc9,
- 0xffcc, 0xffd1, 0xffd4, 0xffd9, 0xffdc, 0xffde, 0x37e, 0x2, 0x3,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xb, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x11, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x13, 0x3, 0x2, 0x2, 0x2, 0x2, 0x15,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x17, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x19, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1b,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x1d, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x21,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x23, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x25, 0x3, 0x2, 0x2, 0x2, 0x2, 0x27,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x29, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2d,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x2f, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x31, 0x3, 0x2, 0x2, 0x2, 0x2, 0x33,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x35, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x37, 0x3, 0x2, 0x2, 0x2, 0x2, 0x39,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x3b, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3f,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x41, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x43, 0x3, 0x2, 0x2, 0x2, 0x2, 0x45,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x47, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x49, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4b,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x4d, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x51,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x53, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x55, 0x3, 0x2, 0x2, 0x2, 0x2, 0x57,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x59, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5d,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x5f, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x61, 0x3, 0x2, 0x2, 0x2, 0x2, 0x63,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x65, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x67, 0x3, 0x2, 0x2, 0x2, 0x2, 0x69,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x6b, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x6d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x6f,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x71, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x73, 0x3, 0x2, 0x2, 0x2, 0x2, 0x75,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x77, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x79, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7b,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x7d, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x81,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x83, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x85, 0x3, 0x2, 0x2, 0x2, 0x2, 0x87,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x89, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x8d,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x8f, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x91, 0x3, 0x2, 0x2, 0x2, 0x2, 0x93,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x95, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x97, 0x3, 0x2, 0x2, 0x2, 0x2, 0x99,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0x9b, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9f,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xa1, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa5,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xa7, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xab,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xad, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb1,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xb3, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xb5, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb7,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xb9, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xbb, 0x3, 0x2, 0x2, 0x2, 0x2, 0xbd,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xbf, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xc1, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc3,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xc5, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc9,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xcb, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xcf,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xd1, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xd3, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd5,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xd7, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xd9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xdb,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xdd, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xdf, 0x3, 0x2, 0x2, 0x2, 0x2, 0xe1,
- 0x3, 0x2, 0x2, 0x2, 0x2, 0xe3, 0x3, 0x2, 0x2,
- 0x2, 0x2, 0xe5, 0x3, 0x2, 0x2, 0x2, 0x3, 0x10d,
- 0x3, 0x2, 0x2, 0x2, 0x5, 0x10f, 0x3, 0x2, 0x2,
- 0x2, 0x7, 0x111, 0x3, 0x2, 0x2, 0x2, 0x9, 0x113,
- 0x3, 0x2, 0x2, 0x2, 0xb, 0x116, 0x3, 0x2, 0x2,
- 0x2, 0xd, 0x118, 0x3, 0x2, 0x2, 0x2, 0xf, 0x11a,
- 0x3, 0x2, 0x2, 0x2, 0x11, 0x11c, 0x3, 0x2, 0x2,
- 0x2, 0x13, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x15, 0x120,
- 0x3, 0x2, 0x2, 0x2, 0x17, 0x122, 0x3, 0x2, 0x2,
- 0x2, 0x19, 0x124, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x126,
- 0x3, 0x2, 0x2, 0x2, 0x1d, 0x129, 0x3, 0x2, 0x2,
- 0x2, 0x1f, 0x12b, 0x3, 0x2, 0x2, 0x2, 0x21, 0x12d,
- 0x3, 0x2, 0x2, 0x2, 0x23, 0x12f, 0x3, 0x2, 0x2,
- 0x2, 0x25, 0x131, 0x3, 0x2, 0x2, 0x2, 0x27, 0x133,
- 0x3, 0x2, 0x2, 0x2, 0x29, 0x136, 0x3, 0x2, 0x2,
- 0x2, 0x2b, 0x139, 0x3, 0x2, 0x2, 0x2, 0x2d, 0x13c,
- 0x3, 0x2, 0x2, 0x2, 0x2f, 0x13e, 0x3, 0x2, 0x2,
- 0x2, 0x31, 0x140, 0x3, 0x2, 0x2, 0x2, 0x33, 0x143,
- 0x3, 0x2, 0x2, 0x2, 0x35, 0x146, 0x3, 0x2, 0x2,
- 0x2, 0x37, 0x148, 0x3, 0x2, 0x2, 0x2, 0x39, 0x14a,
- 0x3, 0x2, 0x2, 0x2, 0x3b, 0x14c, 0x3, 0x2, 0x2,
- 0x2, 0x3d, 0x14e, 0x3, 0x2, 0x2, 0x2, 0x3f, 0x150,
- 0x3, 0x2, 0x2, 0x2, 0x41, 0x152, 0x3, 0x2, 0x2,
- 0x2, 0x43, 0x154, 0x3, 0x2, 0x2, 0x2, 0x45, 0x156,
- 0x3, 0x2, 0x2, 0x2, 0x47, 0x158, 0x3, 0x2, 0x2,
- 0x2, 0x49, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x4b, 0x15c,
- 0x3, 0x2, 0x2, 0x2, 0x4d, 0x15e, 0x3, 0x2, 0x2,
- 0x2, 0x4f, 0x160, 0x3, 0x2, 0x2, 0x2, 0x51, 0x162,
- 0x3, 0x2, 0x2, 0x2, 0x53, 0x164, 0x3, 0x2, 0x2,
- 0x2, 0x55, 0x166, 0x3, 0x2, 0x2, 0x2, 0x57, 0x168,
- 0x3, 0x2, 0x2, 0x2, 0x59, 0x16a, 0x3, 0x2, 0x2,
- 0x2, 0x5b, 0x16c, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x16e,
- 0x3, 0x2, 0x2, 0x2, 0x5f, 0x170, 0x3, 0x2, 0x2,
- 0x2, 0x61, 0x172, 0x3, 0x2, 0x2, 0x2, 0x63, 0x174,
- 0x3, 0x2, 0x2, 0x2, 0x65, 0x188, 0x3, 0x2, 0x2,
- 0x2, 0x67, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x69, 0x19e,
- 0x3, 0x2, 0x2, 0x2, 0x6b, 0x1ac, 0x3, 0x2, 0x2,
- 0x2, 0x6d, 0x1ae, 0x3, 0x2, 0x2, 0x2, 0x6f, 0x1b5,
- 0x3, 0x2, 0x2, 0x2, 0x71, 0x1b9, 0x3, 0x2, 0x2,
- 0x2, 0x73, 0x1bd, 0x3, 0x2, 0x2, 0x2, 0x75, 0x1c1,
- 0x3, 0x2, 0x2, 0x2, 0x77, 0x1c3, 0x3, 0x2, 0x2,
- 0x2, 0x79, 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x7b, 0x1c9,
- 0x3, 0x2, 0x2, 0x2, 0x7d, 0x1e1, 0x3, 0x2, 0x2,
- 0x2, 0x7f, 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x81, 0x1fa,
- 0x3, 0x2, 0x2, 0x2, 0x83, 0x200, 0x3, 0x2, 0x2,
- 0x2, 0x85, 0x204, 0x3, 0x2, 0x2, 0x2, 0x87, 0x20d,
- 0x3, 0x2, 0x2, 0x2, 0x89, 0x213, 0x3, 0x2, 0x2,
- 0x2, 0x8b, 0x21a, 0x3, 0x2, 0x2, 0x2, 0x8d, 0x21d,
- 0x3, 0x2, 0x2, 0x2, 0x8f, 0x223, 0x3, 0x2, 0x2,
- 0x2, 0x91, 0x226, 0x3, 0x2, 0x2, 0x2, 0x93, 0x22d,
- 0x3, 0x2, 0x2, 0x2, 0x95, 0x231, 0x3, 0x2, 0x2,
- 0x2, 0x97, 0x238, 0x3, 0x2, 0x2, 0x2, 0x99, 0x23f,
- 0x3, 0x2, 0x2, 0x2, 0x9b, 0x246, 0x3, 0x2, 0x2,
- 0x2, 0x9d, 0x24b, 0x3, 0x2, 0x2, 0x2, 0x9f, 0x254,
- 0x3, 0x2, 0x2, 0x2, 0xa1, 0x25b, 0x3, 0x2, 0x2,
- 0x2, 0xa3, 0x261, 0x3, 0x2, 0x2, 0x2, 0xa5, 0x264,
- 0x3, 0x2, 0x2, 0x2, 0xa7, 0x269, 0x3, 0x2, 0x2,
- 0x2, 0xa9, 0x26f, 0x3, 0x2, 0x2, 0x2, 0xab, 0x279,
- 0x3, 0x2, 0x2, 0x2, 0xad, 0x27d, 0x3, 0x2, 0x2,
- 0x2, 0xaf, 0x288, 0x3, 0x2, 0x2, 0x2, 0xb1, 0x28d,
- 0x3, 0x2, 0x2, 0x2, 0xb3, 0x293, 0x3, 0x2, 0x2,
- 0x2, 0xb5, 0x296, 0x3, 0x2, 0x2, 0x2, 0xb7, 0x29a,
- 0x3, 0x2, 0x2, 0x2, 0xb9, 0x29e, 0x3, 0x2, 0x2,
- 0x2, 0xbb, 0x2a2, 0x3, 0x2, 0x2, 0x2, 0xbd, 0x2a5,
- 0x3, 0x2, 0x2, 0x2, 0xbf, 0x2ac, 0x3, 0x2, 0x2,
- 0x2, 0xc1, 0x2b1, 0x3, 0x2, 0x2, 0x2, 0xc3, 0x2ba,
- 0x3, 0x2, 0x2, 0x2, 0xc5, 0x2bd, 0x3, 0x2, 0x2,
- 0x2, 0xc7, 0x2c2, 0x3, 0x2, 0x2, 0x2, 0xc9, 0x2c8,
- 0x3, 0x2, 0x2, 0x2, 0xcb, 0x2cf, 0x3, 0x2, 0x2,
- 0x2, 0xcd, 0x2d7, 0x3, 0x2, 0x2, 0x2, 0xcf, 0x2db,
- 0x3, 0x2, 0x2, 0x2, 0xd1, 0x2e0, 0x3, 0x2, 0x2,
- 0x2, 0xd3, 0x2e7, 0x3, 0x2, 0x2, 0x2, 0xd5, 0x2ec,
- 0x3, 0x2, 0x2, 0x2, 0xd7, 0x2f2, 0x3, 0x2, 0x2,
- 0x2, 0xd9, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0xdb, 0x2ff,
- 0x3, 0x2, 0x2, 0x2, 0xdd, 0x309, 0x3, 0x2, 0x2,
- 0x2, 0xdf, 0x30e, 0x3, 0x2, 0x2, 0x2, 0xe1, 0x31e,
- 0x3, 0x2, 0x2, 0x2, 0xe3, 0x338, 0x3, 0x2, 0x2,
- 0x2, 0xe5, 0x33a, 0x3, 0x2, 0x2, 0x2, 0xe7, 0x33d,
- 0x3, 0x2, 0x2, 0x2, 0xe9, 0x33f, 0x3, 0x2, 0x2,
- 0x2, 0xeb, 0x341, 0x3, 0x2, 0x2, 0x2, 0xed, 0x343,
- 0x3, 0x2, 0x2, 0x2, 0xef, 0x345, 0x3, 0x2, 0x2,
- 0x2, 0xf1, 0x347, 0x3, 0x2, 0x2, 0x2, 0xf3, 0x349,
- 0x3, 0x2, 0x2, 0x2, 0xf5, 0x34b, 0x3, 0x2, 0x2,
- 0x2, 0xf7, 0x34d, 0x3, 0x2, 0x2, 0x2, 0xf9, 0x34f,
- 0x3, 0x2, 0x2, 0x2, 0xfb, 0x351, 0x3, 0x2, 0x2,
- 0x2, 0xfd, 0x353, 0x3, 0x2, 0x2, 0x2, 0xff, 0x355,
- 0x3, 0x2, 0x2, 0x2, 0x101, 0x357, 0x3, 0x2, 0x2,
- 0x2, 0x103, 0x359, 0x3, 0x2, 0x2, 0x2, 0x105, 0x35b,
- 0x3, 0x2, 0x2, 0x2, 0x107, 0x35d, 0x3, 0x2, 0x2,
- 0x2, 0x109, 0x35f, 0x3, 0x2, 0x2, 0x2, 0x10b, 0x361,
- 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10e, 0x7, 0x3d, 0x2,
- 0x2, 0x10e, 0x4, 0x3, 0x2, 0x2, 0x2, 0x10f, 0x110,
- 0x7, 0x2e, 0x2, 0x2, 0x110, 0x6, 0x3, 0x2, 0x2,
- 0x2, 0x111, 0x112, 0x7, 0x3f, 0x2, 0x2, 0x112, 0x8,
- 0x3, 0x2, 0x2, 0x2, 0x113, 0x114, 0x7, 0x2d, 0x2,
- 0x2, 0x114, 0x115, 0x7, 0x3f, 0x2, 0x2, 0x115, 0xa,
- 0x3, 0x2, 0x2, 0x2, 0x116, 0x117, 0x7, 0x2c, 0x2,
- 0x2, 0x117, 0xc, 0x3, 0x2, 0x2, 0x2, 0x118, 0x119,
- 0x7, 0x2a, 0x2, 0x2, 0x119, 0xe, 0x3, 0x2, 0x2,
- 0x2, 0x11a, 0x11b, 0x7, 0x2b, 0x2, 0x2, 0x11b, 0x10,
- 0x3, 0x2, 0x2, 0x2, 0x11c, 0x11d, 0x7, 0x5d, 0x2,
- 0x2, 0x11d, 0x12, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x11f,
- 0x7, 0x41, 0x2, 0x2, 0x11f, 0x14, 0x3, 0x2, 0x2,
- 0x2, 0x120, 0x121, 0x7, 0x5f, 0x2, 0x2, 0x121, 0x16,
- 0x3, 0x2, 0x2, 0x2, 0x122, 0x123, 0x7, 0x3c, 0x2,
- 0x2, 0x123, 0x18, 0x3, 0x2, 0x2, 0x2, 0x124, 0x125,
- 0x7, 0x7e, 0x2, 0x2, 0x125, 0x1a, 0x3, 0x2, 0x2,
- 0x2, 0x126, 0x127, 0x7, 0x30, 0x2, 0x2, 0x127, 0x128,
- 0x7, 0x30, 0x2, 0x2, 0x128, 0x1c, 0x3, 0x2, 0x2,
- 0x2, 0x129, 0x12a, 0x7, 0x2d, 0x2, 0x2, 0x12a, 0x1e,
- 0x3, 0x2, 0x2, 0x2, 0x12b, 0x12c, 0x7, 0x2f, 0x2,
- 0x2, 0x12c, 0x20, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x12e,
- 0x7, 0x31, 0x2, 0x2, 0x12e, 0x22, 0x3, 0x2, 0x2,
- 0x2, 0x12f, 0x130, 0x7, 0x27, 0x2, 0x2, 0x130, 0x24,
- 0x3, 0x2, 0x2, 0x2, 0x131, 0x132, 0x7, 0x60, 0x2,
- 0x2, 0x132, 0x26, 0x3, 0x2, 0x2, 0x2, 0x133, 0x134,
- 0x7, 0x3f, 0x2, 0x2, 0x134, 0x135, 0x7, 0x80, 0x2,
- 0x2, 0x135, 0x28, 0x3, 0x2, 0x2, 0x2, 0x136, 0x137,
- 0x7, 0x3e, 0x2, 0x2, 0x137, 0x138, 0x7, 0x40, 0x2,
- 0x2, 0x138, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13a,
- 0x7, 0x23, 0x2, 0x2, 0x13a, 0x13b, 0x7, 0x3f, 0x2,
- 0x2, 0x13b, 0x2c, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x13d,
- 0x7, 0x3e, 0x2, 0x2, 0x13d, 0x2e, 0x3, 0x2, 0x2,
- 0x2, 0x13e, 0x13f, 0x7, 0x40, 0x2, 0x2, 0x13f, 0x30,
- 0x3, 0x2, 0x2, 0x2, 0x140, 0x141, 0x7, 0x3e, 0x2,
- 0x2, 0x141, 0x142, 0x7, 0x3f, 0x2, 0x2, 0x142, 0x32,
- 0x3, 0x2, 0x2, 0x2, 0x143, 0x144, 0x7, 0x40, 0x2,
- 0x2, 0x144, 0x145, 0x7, 0x3f, 0x2, 0x2, 0x145, 0x34,
- 0x3, 0x2, 0x2, 0x2, 0x146, 0x147, 0x7, 0x30, 0x2,
- 0x2, 0x147, 0x36, 0x3, 0x2, 0x2, 0x2, 0x148, 0x149,
- 0x7, 0x23, 0x2, 0x2, 0x149, 0x38, 0x3, 0x2, 0x2,
- 0x2, 0x14a, 0x14b, 0x7, 0x7d, 0x2, 0x2, 0x14b, 0x3a,
- 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14d, 0x7, 0x7f, 0x2,
- 0x2, 0x14d, 0x3c, 0x3, 0x2, 0x2, 0x2, 0x14e, 0x14f,
- 0x7, 0x26, 0x2, 0x2, 0x14f, 0x3e, 0x3, 0x2, 0x2,
- 0x2, 0x150, 0x151, 0x7, 0x27ea, 0x2, 0x2, 0x151, 0x40,
- 0x3, 0x2, 0x2, 0x2, 0x152, 0x153, 0x7, 0x300a, 0x2,
- 0x2, 0x153, 0x42, 0x3, 0x2, 0x2, 0x2, 0x154, 0x155,
- 0x7, 0xfe66, 0x2, 0x2, 0x155, 0x44, 0x3, 0x2, 0x2,
- 0x2, 0x156, 0x157, 0x7, 0xff1e, 0x2, 0x2, 0x157, 0x46,
- 0x3, 0x2, 0x2, 0x2, 0x158, 0x159, 0x7, 0x27eb, 0x2,
- 0x2, 0x159, 0x48, 0x3, 0x2, 0x2, 0x2, 0x15a, 0x15b,
- 0x7, 0x300b, 0x2, 0x2, 0x15b, 0x4a, 0x3, 0x2, 0x2,
- 0x2, 0x15c, 0x15d, 0x7, 0xfe67, 0x2, 0x2, 0x15d, 0x4c,
- 0x3, 0x2, 0x2, 0x2, 0x15e, 0x15f, 0x7, 0xff20, 0x2,
- 0x2, 0x15f, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x160, 0x161,
- 0x7, 0xaf, 0x2, 0x2, 0x161, 0x50, 0x3, 0x2, 0x2,
- 0x2, 0x162, 0x163, 0x7, 0x2012, 0x2, 0x2, 0x163, 0x52,
- 0x3, 0x2, 0x2, 0x2, 0x164, 0x165, 0x7, 0x2013, 0x2,
- 0x2, 0x165, 0x54, 0x3, 0x2, 0x2, 0x2, 0x166, 0x167,
- 0x7, 0x2014, 0x2, 0x2, 0x167, 0x56, 0x3, 0x2, 0x2,
- 0x2, 0x168, 0x169, 0x7, 0x2015, 0x2, 0x2, 0x169, 0x58,
- 0x3, 0x2, 0x2, 0x2, 0x16a, 0x16b, 0x7, 0x2016, 0x2,
- 0x2, 0x16b, 0x5a, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16d,
- 0x7, 0x2017, 0x2, 0x2, 0x16d, 0x5c, 0x3, 0x2, 0x2,
- 0x2, 0x16e, 0x16f, 0x7, 0x2214, 0x2, 0x2, 0x16f, 0x5e,
- 0x3, 0x2, 0x2, 0x2, 0x170, 0x171, 0x7, 0xfe5a, 0x2,
- 0x2, 0x171, 0x60, 0x3, 0x2, 0x2, 0x2, 0x172, 0x173,
- 0x7, 0xfe65, 0x2, 0x2, 0x173, 0x62, 0x3, 0x2, 0x2,
- 0x2, 0x174, 0x175, 0x7, 0xff0f, 0x2, 0x2, 0x175, 0x64,
- 0x3, 0x2, 0x2, 0x2, 0x176, 0x17b, 0x7, 0x24, 0x2,
- 0x2, 0x177, 0x17a, 0x5, 0x103, 0x82, 0x2, 0x178, 0x17a,
- 0x5, 0x67, 0x34, 0x2, 0x179, 0x177, 0x3, 0x2, 0x2,
- 0x2, 0x179, 0x178, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x17d,
- 0x3, 0x2, 0x2, 0x2, 0x17b, 0x179, 0x3, 0x2, 0x2,
- 0x2, 0x17b, 0x17c, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x17e,
- 0x3, 0x2, 0x2, 0x2, 0x17d, 0x17b, 0x3, 0x2, 0x2,
- 0x2, 0x17e, 0x189, 0x7, 0x24, 0x2, 0x2, 0x17f, 0x184,
- 0x7, 0x29, 0x2, 0x2, 0x180, 0x183, 0x5, 0xf1, 0x79,
- 0x2, 0x181, 0x183, 0x5, 0x67, 0x34, 0x2, 0x182, 0x180,
- 0x3, 0x2, 0x2, 0x2, 0x182, 0x181, 0x3, 0x2, 0x2,
- 0x2, 0x183, 0x186, 0x3, 0x2, 0x2, 0x2, 0x184, 0x182,
- 0x3, 0x2, 0x2, 0x2, 0x184, 0x185, 0x3, 0x2, 0x2,
- 0x2, 0x185, 0x187, 0x3, 0x2, 0x2, 0x2, 0x186, 0x184,
- 0x3, 0x2, 0x2, 0x2, 0x187, 0x189, 0x7, 0x29, 0x2,
- 0x2, 0x188, 0x176, 0x3, 0x2, 0x2, 0x2, 0x188, 0x17f,
- 0x3, 0x2, 0x2, 0x2, 0x189, 0x66, 0x3, 0x2, 0x2,
- 0x2, 0x18a, 0x19c, 0x7, 0x5e, 0x2, 0x2, 0x18b, 0x19d,
- 0x9, 0x2, 0x2, 0x2, 0x18c, 0x18d, 0x9, 0x3, 0x2,
- 0x2, 0x18d, 0x18e, 0x5, 0x71, 0x39, 0x2, 0x18e, 0x18f,
- 0x5, 0x71, 0x39, 0x2, 0x18f, 0x190, 0x5, 0x71, 0x39,
- 0x2, 0x190, 0x191, 0x5, 0x71, 0x39, 0x2, 0x191, 0x19d,
- 0x3, 0x2, 0x2, 0x2, 0x192, 0x193, 0x9, 0x3, 0x2,
- 0x2, 0x193, 0x194, 0x5, 0x71, 0x39, 0x2, 0x194, 0x195,
- 0x5, 0x71, 0x39, 0x2, 0x195, 0x196, 0x5, 0x71, 0x39,
- 0x2, 0x196, 0x197, 0x5, 0x71, 0x39, 0x2, 0x197, 0x198,
- 0x5, 0x71, 0x39, 0x2, 0x198, 0x199, 0x5, 0x71, 0x39,
- 0x2, 0x199, 0x19a, 0x5, 0x71, 0x39, 0x2, 0x19a, 0x19b,
- 0x5, 0x71, 0x39, 0x2, 0x19b, 0x19d, 0x3, 0x2, 0x2,
- 0x2, 0x19c, 0x18b, 0x3, 0x2, 0x2, 0x2, 0x19c, 0x18c,
- 0x3, 0x2, 0x2, 0x2, 0x19c, 0x192, 0x3, 0x2, 0x2,
- 0x2, 0x19d, 0x68, 0x3, 0x2, 0x2, 0x2, 0x19e, 0x1a0,
- 0x5, 0xe5, 0x73, 0x2, 0x19f, 0x1a1, 0x5, 0x71, 0x39,
- 0x2, 0x1a0, 0x19f, 0x3, 0x2, 0x2, 0x2, 0x1a1, 0x1a2,
- 0x3, 0x2, 0x2, 0x2, 0x1a2, 0x1a0, 0x3, 0x2, 0x2,
- 0x2, 0x1a2, 0x1a3, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x6a,
- 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x1ad, 0x5, 0x7b, 0x3e,
- 0x2, 0x1a5, 0x1a9, 0x5, 0x75, 0x3b, 0x2, 0x1a6, 0x1a8,
- 0x5, 0x73, 0x3a, 0x2, 0x1a7, 0x1a6, 0x3, 0x2, 0x2,
- 0x2, 0x1a8, 0x1ab, 0x3, 0x2, 0x2, 0x2, 0x1a9, 0x1a7,
- 0x3, 0x2, 0x2, 0x2, 0x1a9, 0x1aa, 0x3, 0x2, 0x2,
- 0x2, 0x1aa, 0x1ad, 0x3, 0x2, 0x2, 0x2, 0x1ab, 0x1a9,
- 0x3, 0x2, 0x2, 0x2, 0x1ac, 0x1a4, 0x3, 0x2, 0x2,
- 0x2, 0x1ac, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1ad, 0x6c,
- 0x3, 0x2, 0x2, 0x2, 0x1ae, 0x1b0, 0x5, 0x7b, 0x3e,
- 0x2, 0x1af, 0x1b1, 0x5, 0x79, 0x3d, 0x2, 0x1b0, 0x1af,
- 0x3, 0x2, 0x2, 0x2, 0x1b1, 0x1b2, 0x3, 0x2, 0x2,
- 0x2, 0x1b2, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b2, 0x1b3,
- 0x3, 0x2, 0x2, 0x2, 0x1b3, 0x6e, 0x3, 0x2, 0x2,
- 0x2, 0x1b4, 0x1b6, 0x9, 0x4, 0x2, 0x2, 0x1b5, 0x1b4,
- 0x3, 0x2, 0x2, 0x2, 0x1b6, 0x70, 0x3, 0x2, 0x2,
- 0x2, 0x1b7, 0x1ba, 0x5, 0x73, 0x3a, 0x2, 0x1b8, 0x1ba,
- 0x5, 0x6f, 0x38, 0x2, 0x1b9, 0x1b7, 0x3, 0x2, 0x2,
- 0x2, 0x1b9, 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1ba, 0x72,
- 0x3, 0x2, 0x2, 0x2, 0x1bb, 0x1be, 0x5, 0x7b, 0x3e,
- 0x2, 0x1bc, 0x1be, 0x5, 0x75, 0x3b, 0x2, 0x1bd, 0x1bb,
- 0x3, 0x2, 0x2, 0x2, 0x1bd, 0x1bc, 0x3, 0x2, 0x2,
- 0x2, 0x1be, 0x74, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1c2,
- 0x5, 0x77, 0x3c, 0x2, 0x1c0, 0x1c2, 0x4, 0x3a, 0x3b,
- 0x2, 0x1c1, 0x1bf, 0x3, 0x2, 0x2, 0x2, 0x1c1, 0x1c0,
- 0x3, 0x2, 0x2, 0x2, 0x1c2, 0x76, 0x3, 0x2, 0x2,
- 0x2, 0x1c3, 0x1c4, 0x4, 0x33, 0x39, 0x2, 0x1c4, 0x78,
- 0x3, 0x2, 0x2, 0x2, 0x1c5, 0x1c8, 0x5, 0x7b, 0x3e,
- 0x2, 0x1c6, 0x1c8, 0x5, 0x77, 0x3c, 0x2, 0x1c7, 0x1c5,
- 0x3, 0x2, 0x2, 0x2, 0x1c7, 0x1c6, 0x3, 0x2, 0x2,
- 0x2, 0x1c8, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x1c9, 0x1ca,
- 0x7, 0x32, 0x2, 0x2, 0x1ca, 0x7c, 0x3, 0x2, 0x2,
- 0x2, 0x1cb, 0x1cd, 0x5, 0x73, 0x3a, 0x2, 0x1cc, 0x1cb,
- 0x3, 0x2, 0x2, 0x2, 0x1cd, 0x1ce, 0x3, 0x2, 0x2,
- 0x2, 0x1ce, 0x1cc, 0x3, 0x2, 0x2, 0x2, 0x1ce, 0x1cf,
- 0x3, 0x2, 0x2, 0x2, 0x1cf, 0x1e2, 0x3, 0x2, 0x2,
- 0x2, 0x1d0, 0x1d2, 0x5, 0x73, 0x3a, 0x2, 0x1d1, 0x1d0,
- 0x3, 0x2, 0x2, 0x2, 0x1d2, 0x1d3, 0x3, 0x2, 0x2,
- 0x2, 0x1d3, 0x1d1, 0x3, 0x2, 0x2, 0x2, 0x1d3, 0x1d4,
- 0x3, 0x2, 0x2, 0x2, 0x1d4, 0x1d5, 0x3, 0x2, 0x2,
- 0x2, 0x1d5, 0x1d7, 0x7, 0x30, 0x2, 0x2, 0x1d6, 0x1d8,
- 0x5, 0x73, 0x3a, 0x2, 0x1d7, 0x1d6, 0x3, 0x2, 0x2,
- 0x2, 0x1d8, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1d7,
- 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1da, 0x3, 0x2, 0x2,
- 0x2, 0x1da, 0x1e2, 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dd,
- 0x7, 0x30, 0x2, 0x2, 0x1dc, 0x1de, 0x5, 0x73, 0x3a,
- 0x2, 0x1dd, 0x1dc, 0x3, 0x2, 0x2, 0x2, 0x1de, 0x1df,
- 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1dd, 0x3, 0x2, 0x2,
- 0x2, 0x1df, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1e0, 0x1e2,
- 0x3, 0x2, 0x2, 0x2, 0x1e1, 0x1cc, 0x3, 0x2, 0x2,
- 0x2, 0x1e1, 0x1d1, 0x3, 0x2, 0x2, 0x2, 0x1e1, 0x1db,
- 0x3, 0x2, 0x2, 0x2, 0x1e2, 0x1e4, 0x3, 0x2, 0x2,
- 0x2, 0x1e3, 0x1e5, 0x9, 0x5, 0x2, 0x2, 0x1e4, 0x1e3,
- 0x3, 0x2, 0x2, 0x2, 0x1e5, 0x1e7, 0x3, 0x2, 0x2,
- 0x2, 0x1e6, 0x1e8, 0x7, 0x2f, 0x2, 0x2, 0x1e7, 0x1e6,
- 0x3, 0x2, 0x2, 0x2, 0x1e7, 0x1e8, 0x3, 0x2, 0x2,
- 0x2, 0x1e8, 0x1ea, 0x3, 0x2, 0x2, 0x2, 0x1e9, 0x1eb,
- 0x5, 0x73, 0x3a, 0x2, 0x1ea, 0x1e9, 0x3, 0x2, 0x2,
- 0x2, 0x1eb, 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x1ec, 0x1ea,
- 0x3, 0x2, 0x2, 0x2, 0x1ec, 0x1ed, 0x3, 0x2, 0x2,
- 0x2, 0x1ed, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x1ee, 0x1f0,
- 0x5, 0x73, 0x3a, 0x2, 0x1ef, 0x1ee, 0x3, 0x2, 0x2,
- 0x2, 0x1f0, 0x1f3, 0x3, 0x2, 0x2, 0x2, 0x1f1, 0x1ef,
- 0x3, 0x2, 0x2, 0x2, 0x1f1, 0x1f2, 0x3, 0x2, 0x2,
- 0x2, 0x1f2, 0x1f4, 0x3, 0x2, 0x2, 0x2, 0x1f3, 0x1f1,
- 0x3, 0x2, 0x2, 0x2, 0x1f4, 0x1f6, 0x7, 0x30, 0x2,
- 0x2, 0x1f5, 0x1f7, 0x5, 0x73, 0x3a, 0x2, 0x1f6, 0x1f5,
- 0x3, 0x2, 0x2, 0x2, 0x1f7, 0x1f8, 0x3, 0x2, 0x2,
- 0x2, 0x1f8, 0x1f6, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f9,
- 0x3, 0x2, 0x2, 0x2, 0x1f9, 0x80, 0x3, 0x2, 0x2,
- 0x2, 0x1fa, 0x1fb, 0x9, 0x3, 0x2, 0x2, 0x1fb, 0x1fc,
- 0x9, 0x6, 0x2, 0x2, 0x1fc, 0x1fd, 0x9, 0x7, 0x2,
- 0x2, 0x1fd, 0x1fe, 0x9, 0x8, 0x2, 0x2, 0x1fe, 0x1ff,
- 0x9, 0x6, 0x2, 0x2, 0x1ff, 0x82, 0x3, 0x2, 0x2,
- 0x2, 0x200, 0x201, 0x9, 0x9, 0x2, 0x2, 0x201, 0x202,
- 0x9, 0xa, 0x2, 0x2, 0x202, 0x203, 0x9, 0xa, 0x2,
- 0x2, 0x203, 0x84, 0x3, 0x2, 0x2, 0x2, 0x204, 0x205,
- 0x9, 0x8, 0x2, 0x2, 0x205, 0x206, 0x9, 0xb, 0x2,
- 0x2, 0x206, 0x207, 0x9, 0xc, 0x2, 0x2, 0x207, 0x208,
- 0x9, 0x7, 0x2, 0x2, 0x208, 0x209, 0x9, 0x8, 0x2,
- 0x2, 0x209, 0x20a, 0x9, 0x6, 0x2, 0x2, 0x20a, 0x20b,
- 0x9, 0x9, 0x2, 0x2, 0x20b, 0x20c, 0x9, 0xa, 0x2,
- 0x2, 0x20c, 0x86, 0x3, 0x2, 0x2, 0x2, 0x20d, 0x20e,
- 0x9, 0xd, 0x2, 0x2, 0x20e, 0x20f, 0x9, 0x9, 0x2,
- 0x2, 0x20f, 0x210, 0x9, 0xc, 0x2, 0x2, 0x210, 0x211,
- 0x9, 0xe, 0x2, 0x2, 0x211, 0x212, 0x9, 0xf, 0x2,
- 0x2, 0x212, 0x88, 0x3, 0x2, 0x2, 0x2, 0x213, 0x214,
- 0x9, 0x3, 0x2, 0x2, 0x214, 0x215, 0x9, 0x6, 0x2,
- 0x2, 0x215, 0x216, 0x9, 0x10, 0x2, 0x2, 0x216, 0x217,
- 0x9, 0x7, 0x2, 0x2, 0x217, 0x218, 0x9, 0x6, 0x2,
- 0x2, 0x218, 0x219, 0x9, 0x11, 0x2, 0x2, 0x219, 0x8a,
- 0x3, 0x2, 0x2, 0x2, 0x21a, 0x21b, 0x9, 0x9, 0x2,
- 0x2, 0x21b, 0x21c, 0x9, 0x12, 0x2, 0x2, 0x21c, 0x8c,
- 0x3, 0x2, 0x2, 0x2, 0x21d, 0x21e, 0x9, 0xd, 0x2,
- 0x2, 0x21e, 0x21f, 0x9, 0x5, 0x2, 0x2, 0x21f, 0x220,
- 0x9, 0x13, 0x2, 0x2, 0x220, 0x221, 0x9, 0x14, 0x2,
- 0x2, 0x221, 0x222, 0x9, 0x5, 0x2, 0x2, 0x222, 0x8e,
- 0x3, 0x2, 0x2, 0x2, 0x223, 0x224, 0x9, 0x8, 0x2,
- 0x2, 0x224, 0x225, 0x9, 0x6, 0x2, 0x2, 0x225, 0x90,
- 0x3, 0x2, 0x2, 0x2, 0x226, 0x227, 0x9, 0xe, 0x2,
- 0x2, 0x227, 0x228, 0x9, 0x13, 0x2, 0x2, 0x228, 0x229,
- 0x9, 0x5, 0x2, 0x2, 0x229, 0x22a, 0x9, 0x9, 0x2,
- 0x2, 0x22a, 0x22b, 0x9, 0xc, 0x2, 0x2, 0x22b, 0x22c,
- 0x9, 0x5, 0x2, 0x2, 0x22c, 0x92, 0x3, 0x2, 0x2,
- 0x2, 0x22d, 0x22e, 0x9, 0x12, 0x2, 0x2, 0x22e, 0x22f,
- 0x9, 0x5, 0x2, 0x2, 0x22f, 0x230, 0x9, 0xc, 0x2,
- 0x2, 0x230, 0x94, 0x3, 0x2, 0x2, 0x2, 0x231, 0x232,
- 0x9, 0x11, 0x2, 0x2, 0x232, 0x233, 0x9, 0x5, 0x2,
- 0x2, 0x233, 0x234, 0x9, 0xc, 0x2, 0x2, 0x234, 0x235,
- 0x9, 0x9, 0x2, 0x2, 0x235, 0x236, 0x9, 0xe, 0x2,
- 0x2, 0x236, 0x237, 0x9, 0xf, 0x2, 0x2, 0x237, 0x96,
- 0x3, 0x2, 0x2, 0x2, 0x238, 0x239, 0x9, 0x11, 0x2,
- 0x2, 0x239, 0x23a, 0x9, 0x5, 0x2, 0x2, 0x23a, 0x23b,
- 0x9, 0xa, 0x2, 0x2, 0x23b, 0x23c, 0x9, 0x5, 0x2,
- 0x2, 0x23c, 0x23d, 0x9, 0xc, 0x2, 0x2, 0x23d, 0x23e,
- 0x9, 0x5, 0x2, 0x2, 0x23e, 0x98, 0x3, 0x2, 0x2,
- 0x2, 0x23f, 0x240, 0x9, 0x13, 0x2, 0x2, 0x240, 0x241,
- 0x9, 0x5, 0x2, 0x2, 0x241, 0x242, 0x9, 0xd, 0x2,
- 0x2, 0x242, 0x243, 0x9, 0x8, 0x2, 0x2, 0x243, 0x244,
- 0x9, 0x15, 0x2, 0x2, 0x244, 0x245, 0x9, 0x5, 0x2,
- 0x2, 0x245, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x246, 0x247,
- 0x9, 0x10, 0x2, 0x2, 0x247, 0x248, 0x9, 0x7, 0x2,
- 0x2, 0x248, 0x249, 0x9, 0xc, 0x2, 0x2, 0x249, 0x24a,
- 0x9, 0xf, 0x2, 0x2, 0x24a, 0x9c, 0x3, 0x2, 0x2,
- 0x2, 0x24b, 0x24c, 0x9, 0x11, 0x2, 0x2, 0x24c, 0x24d,
- 0x9, 0x7, 0x2, 0x2, 0x24d, 0x24e, 0x9, 0x12, 0x2,
- 0x2, 0x24e, 0x24f, 0x9, 0xc, 0x2, 0x2, 0x24f, 0x250,
- 0x9, 0x7, 0x2, 0x2, 0x250, 0x251, 0x9, 0x6, 0x2,
- 0x2, 0x251, 0x252, 0x9, 0xe, 0x2, 0x2, 0x252, 0x253,
- 0x9, 0xc, 0x2, 0x2, 0x253, 0x9e, 0x3, 0x2, 0x2,
- 0x2, 0x254, 0x255, 0x9, 0x13, 0x2, 0x2, 0x255, 0x256,
- 0x9, 0x5, 0x2, 0x2, 0x256, 0x257, 0x9, 0xc, 0x2,
- 0x2, 0x257, 0x258, 0x9, 0x3, 0x2, 0x2, 0x258, 0x259,
- 0x9, 0x13, 0x2, 0x2, 0x259, 0x25a, 0x9, 0x6, 0x2,
- 0x2, 0x25a, 0xa0, 0x3, 0x2, 0x2, 0x2, 0x25b, 0x25c,
- 0x9, 0x8, 0x2, 0x2, 0x25c, 0x25d, 0x9, 0x13, 0x2,
- 0x2, 0x25d, 0x25e, 0x9, 0x11, 0x2, 0x2, 0x25e, 0x25f,
- 0x9, 0x5, 0x2, 0x2, 0x25f, 0x260, 0x9, 0x13, 0x2,
- 0x2, 0x260, 0xa2, 0x3, 0x2, 0x2, 0x2, 0x261, 0x262,
- 0x9, 0x16, 0x2, 0x2, 0x262, 0x263, 0x9, 0x17, 0x2,
- 0x2, 0x263, 0xa4, 0x3, 0x2, 0x2, 0x2, 0x264, 0x265,
- 0x9, 0x12, 0x2, 0x2, 0x265, 0x266, 0x9, 0x18, 0x2,
- 0x2, 0x266, 0x267, 0x9, 0x7, 0x2, 0x2, 0x267, 0x268,
- 0x9, 0xb, 0x2, 0x2, 0x268, 0xa6, 0x3, 0x2, 0x2,
- 0x2, 0x269, 0x26a, 0x9, 0xa, 0x2, 0x2, 0x26a, 0x26b,
- 0x9, 0x7, 0x2, 0x2, 0x26b, 0x26c, 0x9, 0xd, 0x2,
- 0x2, 0x26c, 0x26d, 0x9, 0x7, 0x2, 0x2, 0x26d, 0x26e,
- 0x9, 0xc, 0x2, 0x2, 0x26e, 0xa8, 0x3, 0x2, 0x2,
- 0x2, 0x26f, 0x270, 0x9, 0x9, 0x2, 0x2, 0x270, 0x271,
- 0x9, 0x12, 0x2, 0x2, 0x271, 0x272, 0x9, 0xe, 0x2,
- 0x2, 0x272, 0x273, 0x9, 0x5, 0x2, 0x2, 0x273, 0x274,
- 0x9, 0x6, 0x2, 0x2, 0x274, 0x275, 0x9, 0x11, 0x2,
- 0x2, 0x275, 0x276, 0x9, 0x7, 0x2, 0x2, 0x276, 0x277,
- 0x9, 0x6, 0x2, 0x2, 0x277, 0x278, 0x9, 0x14, 0x2,
- 0x2, 0x278, 0xaa, 0x3, 0x2, 0x2, 0x2, 0x279, 0x27a,
- 0x9, 0x9, 0x2, 0x2, 0x27a, 0x27b, 0x9, 0x12, 0x2,
- 0x2, 0x27b, 0x27c, 0x9, 0xe, 0x2, 0x2, 0x27c, 0xac,
- 0x3, 0x2, 0x2, 0x2, 0x27d, 0x27e, 0x9, 0x11, 0x2,
- 0x2, 0x27e, 0x27f, 0x9, 0x5, 0x2, 0x2, 0x27f, 0x280,
- 0x9, 0x12, 0x2, 0x2, 0x280, 0x281, 0x9, 0xe, 0x2,
- 0x2, 0x281, 0x282, 0x9, 0x5, 0x2, 0x2, 0x282, 0x283,
- 0x9, 0x6, 0x2, 0x2, 0x283, 0x284, 0x9, 0x11, 0x2,
- 0x2, 0x284, 0x285, 0x9, 0x7, 0x2, 0x2, 0x285, 0x286,
- 0x9, 0x6, 0x2, 0x2, 0x286, 0x287, 0x9, 0x14, 0x2,
- 0x2, 0x287, 0xae, 0x3, 0x2, 0x2, 0x2, 0x288, 0x289,
- 0x9, 0x11, 0x2, 0x2, 0x289, 0x28a, 0x9, 0x5, 0x2,
- 0x2, 0x28a, 0x28b, 0x9, 0x12, 0x2, 0x2, 0x28b, 0x28c,
- 0x9, 0xe, 0x2, 0x2, 0x28c, 0xb0, 0x3, 0x2, 0x2,
- 0x2, 0x28d, 0x28e, 0x9, 0x10, 0x2, 0x2, 0x28e, 0x28f,
- 0x9, 0xf, 0x2, 0x2, 0x28f, 0x290, 0x9, 0x5, 0x2,
- 0x2, 0x290, 0x291, 0x9, 0x13, 0x2, 0x2, 0x291, 0x292,
- 0x9, 0x5, 0x2, 0x2, 0x292, 0xb2, 0x3, 0x2, 0x2,
- 0x2, 0x293, 0x294, 0x9, 0x8, 0x2, 0x2, 0x294, 0x295,
- 0x9, 0x13, 0x2, 0x2, 0x295, 0xb4, 0x3, 0x2, 0x2,
- 0x2, 0x296, 0x297, 0x9, 0x19, 0x2, 0x2, 0x297, 0x298,
- 0x9, 0x8, 0x2, 0x2, 0x298, 0x299, 0x9, 0x13, 0x2,
- 0x2, 0x299, 0xb6, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x29b,
- 0x9, 0x9, 0x2, 0x2, 0x29b, 0x29c, 0x9, 0x6, 0x2,
- 0x2, 0x29c, 0x29d, 0x9, 0x11, 0x2, 0x2, 0x29d, 0xb8,
- 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29f, 0x9, 0x6, 0x2,
- 0x2, 0x29f, 0x2a0, 0x9, 0x8, 0x2, 0x2, 0x2a0, 0x2a1,
- 0x9, 0xc, 0x2, 0x2, 0x2a1, 0xba, 0x3, 0x2, 0x2,
- 0x2, 0x2a2, 0x2a3, 0x9, 0x7, 0x2, 0x2, 0x2a3, 0x2a4,
- 0x9, 0x6, 0x2, 0x2, 0x2a4, 0xbc, 0x3, 0x2, 0x2,
- 0x2, 0x2a5, 0x2a6, 0x9, 0x12, 0x2, 0x2, 0x2a6, 0x2a7,
- 0x9, 0xc, 0x2, 0x2, 0x2a7, 0x2a8, 0x9, 0x9, 0x2,
- 0x2, 0x2a8, 0x2a9, 0x9, 0x13, 0x2, 0x2, 0x2a9, 0x2aa,
- 0x9, 0xc, 0x2, 0x2, 0x2aa, 0x2ab, 0x9, 0x12, 0x2,
- 0x2, 0x2ab, 0xbe, 0x3, 0x2, 0x2, 0x2, 0x2ac, 0x2ad,
- 0x9, 0x5, 0x2, 0x2, 0x2ad, 0x2ae, 0x9, 0x6, 0x2,
- 0x2, 0x2ae, 0x2af, 0x9, 0x11, 0x2, 0x2, 0x2af, 0x2b0,
- 0x9, 0x12, 0x2, 0x2, 0x2b0, 0xc0, 0x3, 0x2, 0x2,
- 0x2, 0x2b1, 0x2b2, 0x9, 0xe, 0x2, 0x2, 0x2b2, 0x2b3,
- 0x9, 0x8, 0x2, 0x2, 0x2b3, 0x2b4, 0x9, 0x6, 0x2,
- 0x2, 0x2b4, 0x2b5, 0x9, 0xc, 0x2, 0x2, 0x2b5, 0x2b6,
- 0x9, 0x9, 0x2, 0x2, 0x2b6, 0x2b7, 0x9, 0x7, 0x2,
- 0x2, 0x2b7, 0x2b8, 0x9, 0x6, 0x2, 0x2, 0x2b8, 0x2b9,
- 0x9, 0x12, 0x2, 0x2, 0x2b9, 0xc2, 0x3, 0x2, 0x2,
- 0x2, 0x2ba, 0x2bb, 0x9, 0x7, 0x2, 0x2, 0x2bb, 0x2bc,
- 0x9, 0x12, 0x2, 0x2, 0x2bc, 0xc4, 0x3, 0x2, 0x2,
- 0x2, 0x2bd, 0x2be, 0x9, 0x6, 0x2, 0x2, 0x2be, 0x2bf,
- 0x9, 0x3, 0x2, 0x2, 0x2bf, 0x2c0, 0x9, 0xa, 0x2,
- 0x2, 0x2c0, 0x2c1, 0x9, 0xa, 0x2, 0x2, 0x2c1, 0xc6,
- 0x3, 0x2, 0x2, 0x2, 0x2c2, 0x2c3, 0x9, 0xe, 0x2,
- 0x2, 0x2c3, 0x2c4, 0x9, 0x8, 0x2, 0x2, 0x2c4, 0x2c5,
- 0x9, 0x3, 0x2, 0x2, 0x2c5, 0x2c6, 0x9, 0x6, 0x2,
- 0x2, 0x2c6, 0x2c7, 0x9, 0xc, 0x2, 0x2, 0x2c7, 0xc8,
- 0x3, 0x2, 0x2, 0x2, 0x2c8, 0x2c9, 0x9, 0x1a, 0x2,
- 0x2, 0x2c9, 0x2ca, 0x9, 0x7, 0x2, 0x2, 0x2ca, 0x2cb,
- 0x9, 0xa, 0x2, 0x2, 0x2cb, 0x2cc, 0x9, 0xc, 0x2,
- 0x2, 0x2cc, 0x2cd, 0x9, 0x5, 0x2, 0x2, 0x2cd, 0x2ce,
- 0x9, 0x13, 0x2, 0x2, 0x2ce, 0xca, 0x3, 0x2, 0x2,
- 0x2, 0x2cf, 0x2d0, 0x9, 0x5, 0x2, 0x2, 0x2d0, 0x2d1,
- 0x9, 0x19, 0x2, 0x2, 0x2d1, 0x2d2, 0x9, 0xc, 0x2,
- 0x2, 0x2d2, 0x2d3, 0x9, 0x13, 0x2, 0x2, 0x2d3, 0x2d4,
- 0x9, 0x9, 0x2, 0x2, 0x2d4, 0x2d5, 0x9, 0xe, 0x2,
- 0x2, 0x2d5, 0x2d6, 0x9, 0xc, 0x2, 0x2, 0x2d6, 0xcc,
- 0x3, 0x2, 0x2, 0x2, 0x2d7, 0x2d8, 0x9, 0x9, 0x2,
- 0x2, 0x2d8, 0x2d9, 0x9, 0x6, 0x2, 0x2, 0x2d9, 0x2da,
- 0x9, 0x17, 0x2, 0x2, 0x2da, 0xce, 0x3, 0x2, 0x2,
- 0x2, 0x2db, 0x2dc, 0x9, 0x6, 0x2, 0x2, 0x2dc, 0x2dd,
- 0x9, 0x8, 0x2, 0x2, 0x2dd, 0x2de, 0x9, 0x6, 0x2,
- 0x2, 0x2de, 0x2df, 0x9, 0x5, 0x2, 0x2, 0x2df, 0xd0,
- 0x3, 0x2, 0x2, 0x2, 0x2e0, 0x2e1, 0x9, 0x12, 0x2,
- 0x2, 0x2e1, 0x2e2, 0x9, 0x7, 0x2, 0x2, 0x2e2, 0x2e3,
- 0x9, 0x6, 0x2, 0x2, 0x2e3, 0x2e4, 0x9, 0x14, 0x2,
- 0x2, 0x2e4, 0x2e5, 0x9, 0xa, 0x2, 0x2, 0x2e5, 0x2e6,
- 0x9, 0x5, 0x2, 0x2, 0x2e6, 0xd2, 0x3, 0x2, 0x2,
- 0x2, 0x2e7, 0x2e8, 0x9, 0xc, 0x2, 0x2, 0x2e8, 0x2e9,
- 0x9, 0x13, 0x2, 0x2, 0x2e9, 0x2ea, 0x9, 0x3, 0x2,
- 0x2, 0x2ea, 0x2eb, 0x9, 0x5, 0x2, 0x2, 0x2eb, 0xd4,
- 0x3, 0x2, 0x2, 0x2, 0x2ec, 0x2ed, 0x9, 0x1a, 0x2,
- 0x2, 0x2ed, 0x2ee, 0x9, 0x9, 0x2, 0x2, 0x2ee, 0x2ef,
- 0x9, 0xa, 0x2, 0x2, 0x2ef, 0x2f0, 0x9, 0x12, 0x2,
- 0x2, 0x2f0, 0x2f1, 0x9, 0x5, 0x2, 0x2, 0x2f1, 0xd6,
- 0x3, 0x2, 0x2, 0x2, 0x2f2, 0x2f6, 0x5, 0xd9, 0x6d,
- 0x2, 0x2f3, 0x2f5, 0x5, 0xdb, 0x6e, 0x2, 0x2f4, 0x2f3,
- 0x3, 0x2, 0x2, 0x2, 0x2f5, 0x2f8, 0x3, 0x2, 0x2,
- 0x2, 0x2f6, 0x2f4, 0x3, 0x2, 0x2, 0x2, 0x2f6, 0x2f7,
- 0x3, 0x2, 0x2, 0x2, 0x2f7, 0xd8, 0x3, 0x2, 0x2,
- 0x2, 0x2f8, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x2f9, 0x2fc,
- 0x5, 0x10b, 0x86, 0x2, 0x2fa, 0x2fc, 0x9, 0x1b, 0x2,
- 0x2, 0x2fb, 0x2f9, 0x3, 0x2, 0x2, 0x2, 0x2fb, 0x2fa,
- 0x3, 0x2, 0x2, 0x2, 0x2fc, 0xda, 0x3, 0x2, 0x2,
- 0x2, 0x2fd, 0x300, 0x5, 0xed, 0x77, 0x2, 0x2fe, 0x300,
- 0x5, 0xfd, 0x7f, 0x2, 0x2ff, 0x2fd, 0x3, 0x2, 0x2,
- 0x2, 0x2ff, 0x2fe, 0x3, 0x2, 0x2, 0x2, 0x300, 0xdc,
- 0x3, 0x2, 0x2, 0x2, 0x301, 0x305, 0x7, 0x62, 0x2,
- 0x2, 0x302, 0x304, 0x5, 0xe9, 0x75, 0x2, 0x303, 0x302,
- 0x3, 0x2, 0x2, 0x2, 0x304, 0x307, 0x3, 0x2, 0x2,
- 0x2, 0x305, 0x303, 0x3, 0x2, 0x2, 0x2, 0x305, 0x306,
- 0x3, 0x2, 0x2, 0x2, 0x306, 0x308, 0x3, 0x2, 0x2,
- 0x2, 0x307, 0x305, 0x3, 0x2, 0x2, 0x2, 0x308, 0x30a,
- 0x7, 0x62, 0x2, 0x2, 0x309, 0x301, 0x3, 0x2, 0x2,
- 0x2, 0x30a, 0x30b, 0x3, 0x2, 0x2, 0x2, 0x30b, 0x309,
- 0x3, 0x2, 0x2, 0x2, 0x30b, 0x30c, 0x3, 0x2, 0x2,
- 0x2, 0x30c, 0xde, 0x3, 0x2, 0x2, 0x2, 0x30d, 0x30f,
- 0x5, 0xe1, 0x71, 0x2, 0x30e, 0x30d, 0x3, 0x2, 0x2,
- 0x2, 0x30f, 0x310, 0x3, 0x2, 0x2, 0x2, 0x310, 0x30e,
- 0x3, 0x2, 0x2, 0x2, 0x310, 0x311, 0x3, 0x2, 0x2,
- 0x2, 0x311, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x312, 0x31f,
- 0x5, 0xff, 0x80, 0x2, 0x313, 0x31f, 0x5, 0x101, 0x81,
- 0x2, 0x314, 0x31f, 0x5, 0x105, 0x83, 0x2, 0x315, 0x31f,
- 0x5, 0x107, 0x84, 0x2, 0x316, 0x31f, 0x5, 0xe7, 0x74,
- 0x2, 0x317, 0x31f, 0x5, 0xfb, 0x7e, 0x2, 0x318, 0x31f,
- 0x5, 0xf9, 0x7d, 0x2, 0x319, 0x31f, 0x5, 0xf7, 0x7c,
- 0x2, 0x31a, 0x31f, 0x5, 0xeb, 0x76, 0x2, 0x31b, 0x31f,
- 0x5, 0x109, 0x85, 0x2, 0x31c, 0x31f, 0x9, 0x1c, 0x2,
- 0x2, 0x31d, 0x31f, 0x5, 0xe3, 0x72, 0x2, 0x31e, 0x312,
- 0x3, 0x2, 0x2, 0x2, 0x31e, 0x313, 0x3, 0x2, 0x2,
- 0x2, 0x31e, 0x314, 0x3, 0x2, 0x2, 0x2, 0x31e, 0x315,
- 0x3, 0x2, 0x2, 0x2, 0x31e, 0x316, 0x3, 0x2, 0x2,
- 0x2, 0x31e, 0x317, 0x3, 0x2, 0x2, 0x2, 0x31e, 0x318,
- 0x3, 0x2, 0x2, 0x2, 0x31e, 0x319, 0x3, 0x2, 0x2,
- 0x2, 0x31e, 0x31a, 0x3, 0x2, 0x2, 0x2, 0x31e, 0x31b,
- 0x3, 0x2, 0x2, 0x2, 0x31e, 0x31c, 0x3, 0x2, 0x2,
- 0x2, 0x31e, 0x31d, 0x3, 0x2, 0x2, 0x2, 0x31f, 0xe2,
- 0x3, 0x2, 0x2, 0x2, 0x320, 0x321, 0x7, 0x31, 0x2,
- 0x2, 0x321, 0x322, 0x7, 0x2c, 0x2, 0x2, 0x322, 0x328,
- 0x3, 0x2, 0x2, 0x2, 0x323, 0x327, 0x5, 0xef, 0x78,
- 0x2, 0x324, 0x325, 0x7, 0x2c, 0x2, 0x2, 0x325, 0x327,
- 0x5, 0xf5, 0x7b, 0x2, 0x326, 0x323, 0x3, 0x2, 0x2,
- 0x2, 0x326, 0x324, 0x3, 0x2, 0x2, 0x2, 0x327, 0x32a,
- 0x3, 0x2, 0x2, 0x2, 0x328, 0x326, 0x3, 0x2, 0x2,
- 0x2, 0x328, 0x329, 0x3, 0x2, 0x2, 0x2, 0x329, 0x32b,
- 0x3, 0x2, 0x2, 0x2, 0x32a, 0x328, 0x3, 0x2, 0x2,
- 0x2, 0x32b, 0x32c, 0x7, 0x2c, 0x2, 0x2, 0x32c, 0x339,
- 0x7, 0x31, 0x2, 0x2, 0x32d, 0x32e, 0x7, 0x31, 0x2,
- 0x2, 0x32e, 0x32f, 0x7, 0x31, 0x2, 0x2, 0x32f, 0x330,
- 0x3, 0x2, 0x2, 0x2, 0x330, 0x332, 0x5, 0xf3, 0x7a,
- 0x2, 0x331, 0x333, 0x5, 0xfb, 0x7e, 0x2, 0x332, 0x331,
- 0x3, 0x2, 0x2, 0x2, 0x332, 0x333, 0x3, 0x2, 0x2,
- 0x2, 0x333, 0x336, 0x3, 0x2, 0x2, 0x2, 0x334, 0x337,
- 0x5, 0x105, 0x83, 0x2, 0x335, 0x337, 0x7, 0x2, 0x2,
- 0x3, 0x336, 0x334, 0x3, 0x2, 0x2, 0x2, 0x336, 0x335,
- 0x3, 0x2, 0x2, 0x2, 0x337, 0x339, 0x3, 0x2, 0x2,
- 0x2, 0x338, 0x320, 0x3, 0x2, 0x2, 0x2, 0x338, 0x32d,
- 0x3, 0x2, 0x2, 0x2, 0x339, 0xe4, 0x3, 0x2, 0x2,
- 0x2, 0x33a, 0x33b, 0x4, 0x32, 0x32, 0x2, 0x33b, 0x33c,
- 0x9, 0x19, 0x2, 0x2, 0x33c, 0xe6, 0x3, 0x2, 0x2,
- 0x2, 0x33d, 0x33e, 0x9, 0x1d, 0x2, 0x2, 0x33e, 0xe8,
- 0x3, 0x2, 0x2, 0x2, 0x33f, 0x340, 0x9, 0x1e, 0x2,
- 0x2, 0x340, 0xea, 0x3, 0x2, 0x2, 0x2, 0x341, 0x342,
- 0x9, 0x1f, 0x2, 0x2, 0x342, 0xec, 0x3, 0x2, 0x2,
- 0x2, 0x343, 0x344, 0x9, 0x20, 0x2, 0x2, 0x344, 0xee,
- 0x3, 0x2, 0x2, 0x2, 0x345, 0x346, 0x9, 0x21, 0x2,
- 0x2, 0x346, 0xf0, 0x3, 0x2, 0x2, 0x2, 0x347, 0x348,
- 0x9, 0x22, 0x2, 0x2, 0x348, 0xf2, 0x3, 0x2, 0x2,
- 0x2, 0x349, 0x34a, 0x9, 0x23, 0x2, 0x2, 0x34a, 0xf4,
- 0x3, 0x2, 0x2, 0x2, 0x34b, 0x34c, 0x9, 0x24, 0x2,
- 0x2, 0x34c, 0xf6, 0x3, 0x2, 0x2, 0x2, 0x34d, 0x34e,
- 0x9, 0x25, 0x2, 0x2, 0x34e, 0xf8, 0x3, 0x2, 0x2,
- 0x2, 0x34f, 0x350, 0x9, 0x26, 0x2, 0x2, 0x350, 0xfa,
- 0x3, 0x2, 0x2, 0x2, 0x351, 0x352, 0x9, 0x27, 0x2,
- 0x2, 0x352, 0xfc, 0x3, 0x2, 0x2, 0x2, 0x353, 0x354,
- 0x9, 0x28, 0x2, 0x2, 0x354, 0xfe, 0x3, 0x2, 0x2,
- 0x2, 0x355, 0x356, 0x9, 0x29, 0x2, 0x2, 0x356, 0x100,
- 0x3, 0x2, 0x2, 0x2, 0x357, 0x358, 0x9, 0x2a, 0x2,
- 0x2, 0x358, 0x102, 0x3, 0x2, 0x2, 0x2, 0x359, 0x35a,
- 0x9, 0x2b, 0x2, 0x2, 0x35a, 0x104, 0x3, 0x2, 0x2,
- 0x2, 0x35b, 0x35c, 0x9, 0x2c, 0x2, 0x2, 0x35c, 0x106,
- 0x3, 0x2, 0x2, 0x2, 0x35d, 0x35e, 0x9, 0x2d, 0x2,
- 0x2, 0x35e, 0x108, 0x3, 0x2, 0x2, 0x2, 0x35f, 0x360,
- 0x9, 0x2e, 0x2, 0x2, 0x360, 0x10a, 0x3, 0x2, 0x2,
- 0x2, 0x361, 0x362, 0x9, 0x2f, 0x2, 0x2, 0x362, 0x10c,
- 0x3, 0x2, 0x2, 0x2, 0x28, 0x2, 0x179, 0x17b, 0x182,
- 0x184, 0x188, 0x19c, 0x1a2, 0x1a9, 0x1ac, 0x1b2, 0x1b5, 0x1b9,
- 0x1bd, 0x1c1, 0x1c7, 0x1ce, 0x1d3, 0x1d9, 0x1df, 0x1e1, 0x1e4,
- 0x1e7, 0x1ec, 0x1f1, 0x1f8, 0x2f6, 0x2fb, 0x2ff, 0x305, 0x30b,
- 0x310, 0x31e, 0x326, 0x328, 0x332, 0x336, 0x338, 0x2,
+ 0x3, 0x430, 0xd6d1, 0x8206, 0xad2d, 0x4417, 0xaef1, 0x8d80, 0xaadd,
+ 0x2, 0x71, 0x35d, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3,
+ 0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7,
+ 0x9, 0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa,
+ 0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe,
+ 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9,
+ 0x11, 0x4, 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14,
+ 0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4,
+ 0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b,
+ 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9,
+ 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21,
+ 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4,
+ 0x25, 0x9, 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28,
+ 0x9, 0x28, 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9,
+ 0x2b, 0x4, 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e,
+ 0x4, 0x2f, 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4,
+ 0x32, 0x9, 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35,
+ 0x9, 0x35, 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9,
+ 0x38, 0x4, 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b,
+ 0x4, 0x3c, 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4,
+ 0x3f, 0x9, 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42,
+ 0x9, 0x42, 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9,
+ 0x45, 0x4, 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48,
+ 0x4, 0x49, 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4,
+ 0x4c, 0x9, 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f,
+ 0x9, 0x4f, 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9,
+ 0x52, 0x4, 0x53, 0x9, 0x53, 0x4, 0x54, 0x9, 0x54, 0x4, 0x55, 0x9, 0x55,
+ 0x4, 0x56, 0x9, 0x56, 0x4, 0x57, 0x9, 0x57, 0x4, 0x58, 0x9, 0x58, 0x4,
+ 0x59, 0x9, 0x59, 0x4, 0x5a, 0x9, 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c,
+ 0x9, 0x5c, 0x4, 0x5d, 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4, 0x5f, 0x9,
+ 0x5f, 0x4, 0x60, 0x9, 0x60, 0x4, 0x61, 0x9, 0x61, 0x4, 0x62, 0x9, 0x62,
+ 0x4, 0x63, 0x9, 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65, 0x4,
+ 0x66, 0x9, 0x66, 0x4, 0x67, 0x9, 0x67, 0x4, 0x68, 0x9, 0x68, 0x4, 0x69,
+ 0x9, 0x69, 0x4, 0x6a, 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, 0x9,
+ 0x6c, 0x4, 0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e, 0x4, 0x6f, 0x9, 0x6f,
+ 0x4, 0x70, 0x9, 0x70, 0x4, 0x71, 0x9, 0x71, 0x4, 0x72, 0x9, 0x72, 0x4,
+ 0x73, 0x9, 0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, 0x9, 0x75, 0x4, 0x76,
+ 0x9, 0x76, 0x4, 0x77, 0x9, 0x77, 0x4, 0x78, 0x9, 0x78, 0x4, 0x79, 0x9,
+ 0x79, 0x4, 0x7a, 0x9, 0x7a, 0x4, 0x7b, 0x9, 0x7b, 0x4, 0x7c, 0x9, 0x7c,
+ 0x4, 0x7d, 0x9, 0x7d, 0x4, 0x7e, 0x9, 0x7e, 0x4, 0x7f, 0x9, 0x7f, 0x4,
+ 0x80, 0x9, 0x80, 0x4, 0x81, 0x9, 0x81, 0x4, 0x82, 0x9, 0x82, 0x4, 0x83,
+ 0x9, 0x83, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4,
+ 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7,
+ 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb,
+ 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe,
+ 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3,
+ 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14,
+ 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3,
+ 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19,
+ 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3,
+ 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f,
+ 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3,
+ 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25,
+ 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 0x3,
+ 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c,
+ 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3,
+ 0x2f, 0x3, 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x7, 0x31,
+ 0x170, 0xa, 0x31, 0xc, 0x31, 0xe, 0x31, 0x173, 0xb, 0x31, 0x3, 0x31,
+ 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x7, 0x31, 0x179, 0xa, 0x31, 0xc, 0x31,
+ 0xe, 0x31, 0x17c, 0xb, 0x31, 0x3, 0x31, 0x5, 0x31, 0x17f, 0xa, 0x31,
+ 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3,
+ 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32,
+ 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x193,
+ 0xa, 0x32, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x6, 0x33, 0x199,
+ 0xa, 0x33, 0xd, 0x33, 0xe, 0x33, 0x19a, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34,
+ 0x7, 0x34, 0x1a0, 0xa, 0x34, 0xc, 0x34, 0xe, 0x34, 0x1a3, 0xb, 0x34,
+ 0x5, 0x34, 0x1a5, 0xa, 0x34, 0x3, 0x35, 0x3, 0x35, 0x6, 0x35, 0x1a9,
+ 0xa, 0x35, 0xd, 0x35, 0xe, 0x35, 0x1aa, 0x3, 0x36, 0x5, 0x36, 0x1ae,
+ 0xa, 0x36, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x1b2, 0xa, 0x37, 0x3, 0x38,
+ 0x3, 0x38, 0x5, 0x38, 0x1b6, 0xa, 0x38, 0x3, 0x39, 0x3, 0x39, 0x5, 0x39,
+ 0x1ba, 0xa, 0x39, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b,
+ 0x1c0, 0xa, 0x3b, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x6, 0x3d, 0x1c5,
+ 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1c6, 0x3, 0x3d, 0x6, 0x3d, 0x1ca,
+ 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1cb, 0x3, 0x3d, 0x3, 0x3d, 0x6, 0x3d,
+ 0x1d0, 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1d1, 0x3, 0x3d, 0x3, 0x3d,
+ 0x6, 0x3d, 0x1d6, 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x1d7, 0x5, 0x3d,
+ 0x1da, 0xa, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x1dd, 0xa, 0x3d, 0x3, 0x3d,
+ 0x5, 0x3d, 0x1e0, 0xa, 0x3d, 0x3, 0x3d, 0x6, 0x3d, 0x1e3, 0xa, 0x3d,
+ 0xd, 0x3d, 0xe, 0x3d, 0x1e4, 0x3, 0x3e, 0x7, 0x3e, 0x1e8, 0xa, 0x3e,
+ 0xc, 0x3e, 0xe, 0x3e, 0x1eb, 0xb, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x6, 0x3e,
+ 0x1ef, 0xa, 0x3e, 0xd, 0x3e, 0xe, 0x3e, 0x1f0, 0x3, 0x3f, 0x3, 0x3f,
+ 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3,
+ 0x40, 0x3, 0x40, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41,
+ 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3,
+ 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43,
+ 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3,
+ 0x44, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45, 0x3, 0x45,
+ 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3,
+ 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x48, 0x3, 0x48, 0x3, 0x48,
+ 0x3, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3,
+ 0x49, 0x3, 0x49, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a,
+ 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3,
+ 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4c,
+ 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3,
+ 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e,
+ 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f, 0x3, 0x4f, 0x3,
+ 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50,
+ 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x51, 0x3, 0x52, 0x3,
+ 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x53, 0x3, 0x53,
+ 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3,
+ 0x53, 0x3, 0x53, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x55,
+ 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3,
+ 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, 0x3, 0x56, 0x3, 0x56, 0x3, 0x56,
+ 0x3, 0x56, 0x3, 0x56, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, 0x3,
+ 0x57, 0x3, 0x57, 0x3, 0x58, 0x3, 0x58, 0x3, 0x58, 0x3, 0x59, 0x3, 0x59,
+ 0x3, 0x59, 0x3, 0x59, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3,
+ 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5c,
+ 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x3,
+ 0x5d, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5f,
+ 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3,
+ 0x5f, 0x3, 0x5f, 0x3, 0x60, 0x3, 0x60, 0x3, 0x60, 0x3, 0x61, 0x3, 0x61,
+ 0x3, 0x61, 0x3, 0x61, 0x3, 0x61, 0x3, 0x62, 0x3, 0x62, 0x3, 0x62, 0x3,
+ 0x62, 0x3, 0x62, 0x3, 0x62, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x3, 0x63,
+ 0x3, 0x63, 0x3, 0x63, 0x3, 0x63, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3,
+ 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x65, 0x3, 0x65,
+ 0x3, 0x65, 0x3, 0x65, 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3, 0x66, 0x3,
+ 0x66, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67, 0x3, 0x67,
+ 0x3, 0x67, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3, 0x68, 0x3,
+ 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x6a,
+ 0x3, 0x6a, 0x7, 0x6a, 0x2ed, 0xa, 0x6a, 0xc, 0x6a, 0xe, 0x6a, 0x2f0,
+ 0xb, 0x6a, 0x3, 0x6b, 0x3, 0x6b, 0x5, 0x6b, 0x2f4, 0xa, 0x6b, 0x3, 0x6c,
+ 0x3, 0x6c, 0x5, 0x6c, 0x2f8, 0xa, 0x6c, 0x3, 0x6d, 0x3, 0x6d, 0x7, 0x6d,
+ 0x2fc, 0xa, 0x6d, 0xc, 0x6d, 0xe, 0x6d, 0x2ff, 0xb, 0x6d, 0x3, 0x6d,
+ 0x6, 0x6d, 0x302, 0xa, 0x6d, 0xd, 0x6d, 0xe, 0x6d, 0x303, 0x3, 0x6e,
+ 0x6, 0x6e, 0x307, 0xa, 0x6e, 0xd, 0x6e, 0xe, 0x6e, 0x308, 0x3, 0x6f,
+ 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3,
+ 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x6f, 0x5, 0x6f, 0x317,
+ 0xa, 0x6f, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3,
+ 0x70, 0x7, 0x70, 0x31f, 0xa, 0x70, 0xc, 0x70, 0xe, 0x70, 0x322, 0xb,
+ 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70, 0x3, 0x70,
+ 0x7, 0x70, 0x32a, 0xa, 0x70, 0xc, 0x70, 0xe, 0x70, 0x32d, 0xb, 0x70,
+ 0x3, 0x70, 0x5, 0x70, 0x330, 0xa, 0x70, 0x3, 0x70, 0x3, 0x70, 0x5, 0x70,
+ 0x334, 0xa, 0x70, 0x5, 0x70, 0x336, 0xa, 0x70, 0x3, 0x71, 0x3, 0x71,
+ 0x3, 0x72, 0x3, 0x72, 0x3, 0x73, 0x3, 0x73, 0x3, 0x74, 0x3, 0x74, 0x3,
+ 0x75, 0x3, 0x75, 0x3, 0x76, 0x3, 0x76, 0x3, 0x77, 0x3, 0x77, 0x3, 0x78,
+ 0x3, 0x78, 0x3, 0x79, 0x3, 0x79, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7b, 0x3,
+ 0x7b, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7e, 0x3, 0x7e,
+ 0x3, 0x7f, 0x3, 0x7f, 0x3, 0x80, 0x3, 0x80, 0x3, 0x81, 0x3, 0x81, 0x3,
+ 0x82, 0x3, 0x82, 0x3, 0x83, 0x3, 0x83, 0x2, 0x2, 0x84, 0x3, 0x3, 0x5,
+ 0x4, 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x11, 0xa, 0x13,
+ 0xb, 0x15, 0xc, 0x17, 0xd, 0x19, 0xe, 0x1b, 0xf, 0x1d, 0x10, 0x1f, 0x11,
+ 0x21, 0x12, 0x23, 0x13, 0x25, 0x14, 0x27, 0x15, 0x29, 0x16, 0x2b, 0x17,
+ 0x2d, 0x18, 0x2f, 0x19, 0x31, 0x1a, 0x33, 0x1b, 0x35, 0x1c, 0x37, 0x1d,
+ 0x39, 0x1e, 0x3b, 0x1f, 0x3d, 0x20, 0x3f, 0x21, 0x41, 0x22, 0x43, 0x23,
+ 0x45, 0x24, 0x47, 0x25, 0x49, 0x26, 0x4b, 0x27, 0x4d, 0x28, 0x4f, 0x29,
+ 0x51, 0x2a, 0x53, 0x2b, 0x55, 0x2c, 0x57, 0x2d, 0x59, 0x2e, 0x5b, 0x2f,
+ 0x5d, 0x30, 0x5f, 0x31, 0x61, 0x32, 0x63, 0x33, 0x65, 0x34, 0x67, 0x35,
+ 0x69, 0x36, 0x6b, 0x37, 0x6d, 0x38, 0x6f, 0x39, 0x71, 0x3a, 0x73, 0x3b,
+ 0x75, 0x3c, 0x77, 0x3d, 0x79, 0x3e, 0x7b, 0x3f, 0x7d, 0x40, 0x7f, 0x41,
+ 0x81, 0x42, 0x83, 0x43, 0x85, 0x44, 0x87, 0x45, 0x89, 0x46, 0x8b, 0x47,
+ 0x8d, 0x48, 0x8f, 0x49, 0x91, 0x4a, 0x93, 0x4b, 0x95, 0x4c, 0x97, 0x4d,
+ 0x99, 0x4e, 0x9b, 0x4f, 0x9d, 0x50, 0x9f, 0x51, 0xa1, 0x52, 0xa3, 0x53,
+ 0xa5, 0x54, 0xa7, 0x55, 0xa9, 0x56, 0xab, 0x57, 0xad, 0x58, 0xaf, 0x59,
+ 0xb1, 0x5a, 0xb3, 0x5b, 0xb5, 0x5c, 0xb7, 0x5d, 0xb9, 0x5e, 0xbb, 0x5f,
+ 0xbd, 0x60, 0xbf, 0x61, 0xc1, 0x62, 0xc3, 0x63, 0xc5, 0x64, 0xc7, 0x65,
+ 0xc9, 0x66, 0xcb, 0x67, 0xcd, 0x68, 0xcf, 0x69, 0xd1, 0x6a, 0xd3, 0x6b,
+ 0xd5, 0x6c, 0xd7, 0x6d, 0xd9, 0x6e, 0xdb, 0x6f, 0xdd, 0x70, 0xdf, 0x71,
+ 0xe1, 0x2, 0xe3, 0x2, 0xe5, 0x2, 0xe7, 0x2, 0xe9, 0x2, 0xeb, 0x2, 0xed,
+ 0x2, 0xef, 0x2, 0xf1, 0x2, 0xf3, 0x2, 0xf5, 0x2, 0xf7, 0x2, 0xf9, 0x2,
+ 0xfb, 0x2, 0xfd, 0x2, 0xff, 0x2, 0x101, 0x2, 0x103, 0x2, 0x105, 0x2,
+ 0x3, 0x2, 0x30, 0xf, 0x2, 0x24, 0x24, 0x29, 0x29, 0x44, 0x44, 0x48,
+ 0x48, 0x50, 0x50, 0x54, 0x54, 0x56, 0x56, 0x5e, 0x5e, 0x64, 0x64, 0x68,
+ 0x68, 0x70, 0x70, 0x74, 0x74, 0x76, 0x76, 0x4, 0x2, 0x57, 0x57, 0x77,
+ 0x77, 0x4, 0x2, 0x43, 0x48, 0x63, 0x68, 0x4, 0x2, 0x47, 0x47, 0x67,
+ 0x67, 0x4, 0x2, 0x50, 0x50, 0x70, 0x70, 0x4, 0x2, 0x4b, 0x4b, 0x6b,
+ 0x6b, 0x4, 0x2, 0x51, 0x51, 0x71, 0x71, 0x4, 0x2, 0x43, 0x43, 0x63,
+ 0x63, 0x4, 0x2, 0x4e, 0x4e, 0x6e, 0x6e, 0x4, 0x2, 0x52, 0x52, 0x72,
+ 0x72, 0x4, 0x2, 0x56, 0x56, 0x76, 0x76, 0x4, 0x2, 0x4f, 0x4f, 0x6f,
+ 0x6f, 0x4, 0x2, 0x45, 0x45, 0x65, 0x65, 0x4, 0x2, 0x4a, 0x4a, 0x6a,
+ 0x6a, 0x4, 0x2, 0x59, 0x59, 0x79, 0x79, 0x4, 0x2, 0x46, 0x46, 0x66,
+ 0x66, 0x4, 0x2, 0x55, 0x55, 0x75, 0x75, 0x4, 0x2, 0x54, 0x54, 0x74,
+ 0x74, 0x4, 0x2, 0x49, 0x49, 0x69, 0x69, 0x4, 0x2, 0x58, 0x58, 0x78,
+ 0x78, 0x4, 0x2, 0x44, 0x44, 0x64, 0x64, 0x4, 0x2, 0x5b, 0x5b, 0x7b,
+ 0x7b, 0x4, 0x2, 0x4d, 0x4d, 0x6d, 0x6d, 0x4, 0x2, 0x5a, 0x5a, 0x7a,
+ 0x7a, 0x4, 0x2, 0x48, 0x48, 0x68, 0x68, 0x8, 0x2, 0x61, 0x61, 0x2041,
+ 0x2042, 0x2056, 0x2056, 0xfe35, 0xfe36, 0xfe4f, 0xfe51, 0xff41, 0xff41,
+ 0xa, 0x2, 0xa2, 0xa2, 0x1682, 0x1682, 0x1810, 0x1810, 0x2002, 0x200c,
+ 0x202a, 0x202b, 0x2031, 0x2031, 0x2061, 0x2061, 0x3002, 0x3002, 0x3,
+ 0x2, 0xe, 0xe, 0x4, 0x2, 0x2, 0x61, 0x63, 0x1, 0x3, 0x2, 0x20, 0x20,
+ 0x1af, 0x2, 0x32, 0x3b, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0xac, 0xac,
+ 0xb7, 0xb7, 0xb9, 0xb9, 0xbc, 0xbc, 0xc2, 0xd8, 0xda, 0xf8, 0xfa, 0x2c3,
+ 0x2c8, 0x2d3, 0x2e2, 0x2e6, 0x2ee, 0x2ee, 0x2f0, 0x2f0, 0x302, 0x376,
+ 0x378, 0x379, 0x37c, 0x37f, 0x388, 0x38c, 0x38e, 0x38e, 0x390, 0x3a3,
+ 0x3a5, 0x3f7, 0x3f9, 0x483, 0x485, 0x489, 0x48c, 0x529, 0x533, 0x558,
+ 0x55b, 0x55b, 0x563, 0x589, 0x593, 0x5bf, 0x5c1, 0x5c1, 0x5c3, 0x5c4,
+ 0x5c6, 0x5c7, 0x5c9, 0x5c9, 0x5d2, 0x5ec, 0x5f2, 0x5f4, 0x612, 0x61c,
+ 0x622, 0x66b, 0x670, 0x6d5, 0x6d7, 0x6de, 0x6e1, 0x6ea, 0x6ec, 0x6fe,
+ 0x701, 0x701, 0x712, 0x74c, 0x74f, 0x7b3, 0x7c2, 0x7f7, 0x7fc, 0x7fc,
+ 0x802, 0x82f, 0x842, 0x85d, 0x8a2, 0x8a2, 0x8a4, 0x8ae, 0x8e6, 0x900,
+ 0x902, 0x965, 0x968, 0x971, 0x973, 0x979, 0x97b, 0x981, 0x983, 0x985,
+ 0x987, 0x98e, 0x991, 0x992, 0x995, 0x9aa, 0x9ac, 0x9b2, 0x9b4, 0x9b4,
+ 0x9b8, 0x9bb, 0x9be, 0x9c6, 0x9c9, 0x9ca, 0x9cd, 0x9d0, 0x9d9, 0x9d9,
+ 0x9de, 0x9df, 0x9e1, 0x9e5, 0x9e8, 0x9f3, 0xa03, 0xa05, 0xa07, 0xa0c,
+ 0xa11, 0xa12, 0xa15, 0xa2a, 0xa2c, 0xa32, 0xa34, 0xa35, 0xa37, 0xa38,
+ 0xa3a, 0xa3b, 0xa3e, 0xa3e, 0xa40, 0xa44, 0xa49, 0xa4a, 0xa4d, 0xa4f,
+ 0xa53, 0xa53, 0xa5b, 0xa5e, 0xa60, 0xa60, 0xa68, 0xa77, 0xa83, 0xa85,
+ 0xa87, 0xa8f, 0xa91, 0xa93, 0xa95, 0xaaa, 0xaac, 0xab2, 0xab4, 0xab5,
+ 0xab7, 0xabb, 0xabe, 0xac7, 0xac9, 0xacb, 0xacd, 0xacf, 0xad2, 0xad2,
+ 0xae2, 0xae5, 0xae8, 0xaf1, 0xb03, 0xb05, 0xb07, 0xb0e, 0xb11, 0xb12,
+ 0xb15, 0xb2a, 0xb2c, 0xb32, 0xb34, 0xb35, 0xb37, 0xb3b, 0xb3e, 0xb46,
+ 0xb49, 0xb4a, 0xb4d, 0xb4f, 0xb58, 0xb59, 0xb5e, 0xb5f, 0xb61, 0xb65,
+ 0xb68, 0xb71, 0xb73, 0xb73, 0xb84, 0xb85, 0xb87, 0xb8c, 0xb90, 0xb92,
+ 0xb94, 0xb97, 0xb9b, 0xb9c, 0xb9e, 0xb9e, 0xba0, 0xba1, 0xba5, 0xba6,
+ 0xbaa, 0xbac, 0xbb0, 0xbbb, 0xbc0, 0xbc4, 0xbc8, 0xbca, 0xbcc, 0xbcf,
+ 0xbd2, 0xbd2, 0xbd9, 0xbd9, 0xbe8, 0xbf1, 0xc03, 0xc05, 0xc07, 0xc0e,
+ 0xc10, 0xc12, 0xc14, 0xc2a, 0xc2c, 0xc35, 0xc37, 0xc3b, 0xc3f, 0xc46,
+ 0xc48, 0xc4a, 0xc4c, 0xc4f, 0xc57, 0xc58, 0xc5a, 0xc5b, 0xc62, 0xc65,
+ 0xc68, 0xc71, 0xc84, 0xc85, 0xc87, 0xc8e, 0xc90, 0xc92, 0xc94, 0xcaa,
+ 0xcac, 0xcb5, 0xcb7, 0xcbb, 0xcbe, 0xcc6, 0xcc8, 0xcca, 0xccc, 0xccf,
+ 0xcd7, 0xcd8, 0xce0, 0xce0, 0xce2, 0xce5, 0xce8, 0xcf1, 0xcf3, 0xcf4,
+ 0xd04, 0xd05, 0xd07, 0xd0e, 0xd10, 0xd12, 0xd14, 0xd3c, 0xd3f, 0xd46,
+ 0xd48, 0xd4a, 0xd4c, 0xd50, 0xd59, 0xd59, 0xd62, 0xd65, 0xd68, 0xd71,
+ 0xd7c, 0xd81, 0xd84, 0xd85, 0xd87, 0xd98, 0xd9c, 0xdb3, 0xdb5, 0xdbd,
+ 0xdbf, 0xdbf, 0xdc2, 0xdc8, 0xdcc, 0xdcc, 0xdd1, 0xdd6, 0xdd8, 0xdd8,
+ 0xdda, 0xde1, 0xdf4, 0xdf5, 0xe03, 0xe3c, 0xe42, 0xe50, 0xe52, 0xe5b,
+ 0xe83, 0xe84, 0xe86, 0xe86, 0xe89, 0xe8a, 0xe8c, 0xe8c, 0xe8f, 0xe8f,
+ 0xe96, 0xe99, 0xe9b, 0xea1, 0xea3, 0xea5, 0xea7, 0xea7, 0xea9, 0xea9,
+ 0xeac, 0xead, 0xeaf, 0xebb, 0xebd, 0xebf, 0xec2, 0xec6, 0xec8, 0xec8,
+ 0xeca, 0xecf, 0xed2, 0xedb, 0xede, 0xee1, 0xf02, 0xf02, 0xf1a, 0xf1b,
+ 0xf22, 0xf2b, 0xf37, 0xf37, 0xf39, 0xf39, 0xf3b, 0xf3b, 0xf40, 0xf49,
+ 0xf4b, 0xf6e, 0xf73, 0xf86, 0xf88, 0xf99, 0xf9b, 0xfbe, 0xfc8, 0xfc8,
+ 0x1002, 0x104b, 0x1052, 0x109f, 0x10a2, 0x10c7, 0x10c9, 0x10c9, 0x10cf,
+ 0x10cf, 0x10d2, 0x10fc, 0x10fe, 0x124a, 0x124c, 0x124f, 0x1252, 0x1258,
+ 0x125a, 0x125a, 0x125c, 0x125f, 0x1262, 0x128a, 0x128c, 0x128f, 0x1292,
+ 0x12b2, 0x12b4, 0x12b7, 0x12ba, 0x12c0, 0x12c2, 0x12c2, 0x12c4, 0x12c7,
+ 0x12ca, 0x12d8, 0x12da, 0x1312, 0x1314, 0x1317, 0x131a, 0x135c, 0x135f,
+ 0x1361, 0x136b, 0x1373, 0x1382, 0x1391, 0x13a2, 0x13f6, 0x1403, 0x166e,
+ 0x1671, 0x1681, 0x1683, 0x169c, 0x16a2, 0x16ec, 0x16f0, 0x16f2, 0x1702,
+ 0x170e, 0x1710, 0x1716, 0x1722, 0x1736, 0x1742, 0x1755, 0x1762, 0x176e,
+ 0x1770, 0x1772, 0x1774, 0x1775, 0x1782, 0x17d5, 0x17d9, 0x17d9, 0x17de,
+ 0x17df, 0x17e2, 0x17eb, 0x180d, 0x180f, 0x1812, 0x181b, 0x1822, 0x1879,
+ 0x1882, 0x18ac, 0x18b2, 0x18f7, 0x1902, 0x191e, 0x1922, 0x192d, 0x1932,
+ 0x193d, 0x1948, 0x196f, 0x1972, 0x1976, 0x1982, 0x19ad, 0x19b2, 0x19cb,
+ 0x19d2, 0x19dc, 0x1a02, 0x1a1d, 0x1a22, 0x1a60, 0x1a62, 0x1a7e, 0x1a81,
+ 0x1a8b, 0x1a92, 0x1a9b, 0x1aa9, 0x1aa9, 0x1b02, 0x1b4d, 0x1b52, 0x1b5b,
+ 0x1b6d, 0x1b75, 0x1b82, 0x1bf5, 0x1c02, 0x1c39, 0x1c42, 0x1c4b, 0x1c4f,
+ 0x1c7f, 0x1cd2, 0x1cd4, 0x1cd6, 0x1cf8, 0x1d02, 0x1de8, 0x1dfe, 0x1f17,
+ 0x1f1a, 0x1f1f, 0x1f22, 0x1f47, 0x1f4a, 0x1f4f, 0x1f52, 0x1f59, 0x1f5b,
+ 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f5f, 0x1f61, 0x1f7f, 0x1f82, 0x1fb6,
+ 0x1fb8, 0x1fbe, 0x1fc0, 0x1fc0, 0x1fc4, 0x1fc6, 0x1fc8, 0x1fce, 0x1fd2,
+ 0x1fd5, 0x1fd8, 0x1fdd, 0x1fe2, 0x1fee, 0x1ff4, 0x1ff6, 0x1ff8, 0x1ffe,
+ 0x2041, 0x2042, 0x2056, 0x2056, 0x2073, 0x2073, 0x2081, 0x2081, 0x2092,
+ 0x209e, 0x20d2, 0x20de, 0x20e3, 0x20e3, 0x20e7, 0x20f2, 0x2104, 0x2104,
+ 0x2109, 0x2109, 0x210c, 0x2115, 0x2117, 0x2117, 0x211a, 0x211f, 0x2126,
+ 0x2126, 0x2128, 0x2128, 0x212a, 0x212a, 0x212c, 0x213b, 0x213e, 0x2141,
+ 0x2147, 0x214b, 0x2150, 0x2150, 0x2162, 0x218a, 0x2c02, 0x2c30, 0x2c32,
+ 0x2c60, 0x2c62, 0x2ce6, 0x2ced, 0x2cf5, 0x2d02, 0x2d27, 0x2d29, 0x2d29,
+ 0x2d2f, 0x2d2f, 0x2d32, 0x2d69, 0x2d71, 0x2d71, 0x2d81, 0x2d98, 0x2da2,
+ 0x2da8, 0x2daa, 0x2db0, 0x2db2, 0x2db8, 0x2dba, 0x2dc0, 0x2dc2, 0x2dc8,
+ 0x2dca, 0x2dd0, 0x2dd2, 0x2dd8, 0x2dda, 0x2de0, 0x2de2, 0x2e01, 0x3007,
+ 0x3009, 0x3023, 0x3031, 0x3033, 0x3037, 0x303a, 0x303e, 0x3043, 0x3098,
+ 0x309b, 0x30a1, 0x30a3, 0x30fc, 0x30fe, 0x3101, 0x3107, 0x312f, 0x3133,
+ 0x3190, 0x31a2, 0x31bc, 0x31f2, 0x3201, 0x3402, 0x4db7, 0x4e02, 0x9fce,
+ 0xa002, 0xa48e, 0xa4d2, 0xa4ff, 0xa502, 0xa60e, 0xa612, 0xa62d, 0xa642,
+ 0xa671, 0xa676, 0xa67f, 0xa681, 0xa699, 0xa6a1, 0xa6f3, 0xa719, 0xa721,
+ 0xa724, 0xa78a, 0xa78d, 0xa790, 0xa792, 0xa795, 0xa7a2, 0xa7ac, 0xa7fa,
+ 0xa829, 0xa842, 0xa875, 0xa882, 0xa8c6, 0xa8d2, 0xa8db, 0xa8e2, 0xa8f9,
+ 0xa8fd, 0xa8fd, 0xa902, 0xa92f, 0xa932, 0xa955, 0xa962, 0xa97e, 0xa982,
+ 0xa9c2, 0xa9d1, 0xa9db, 0xaa02, 0xaa38, 0xaa42, 0xaa4f, 0xaa52, 0xaa5b,
+ 0xaa62, 0xaa78, 0xaa7c, 0xaa7d, 0xaa82, 0xaac4, 0xaadd, 0xaadf, 0xaae2,
+ 0xaaf1, 0xaaf4, 0xaaf8, 0xab03, 0xab08, 0xab0b, 0xab10, 0xab13, 0xab18,
+ 0xab22, 0xab28, 0xab2a, 0xab30, 0xabc2, 0xabec, 0xabee, 0xabef, 0xabf2,
+ 0xabfb, 0xac02, 0xd7a5, 0xd7b2, 0xd7c8, 0xd7cd, 0xd7fd, 0xf902, 0xfa6f,
+ 0xfa72, 0xfadb, 0xfb02, 0xfb08, 0xfb15, 0xfb19, 0xfb1f, 0xfb2a, 0xfb2c,
+ 0xfb38, 0xfb3a, 0xfb3e, 0xfb40, 0xfb40, 0xfb42, 0xfb43, 0xfb45, 0xfb46,
+ 0xfb48, 0xfbb3, 0xfbd5, 0xfd3f, 0xfd52, 0xfd91, 0xfd94, 0xfdc9, 0xfdf2,
+ 0xfdfd, 0xfe02, 0xfe11, 0xfe22, 0xfe28, 0xfe35, 0xfe36, 0xfe4f, 0xfe51,
+ 0xfe72, 0xfe76, 0xfe78, 0xfefe, 0xff12, 0xff1b, 0xff23, 0xff3c, 0xff41,
+ 0xff41, 0xff43, 0xff5c, 0xff68, 0xffc0, 0xffc4, 0xffc9, 0xffcc, 0xffd1,
+ 0xffd4, 0xffd9, 0xffdc, 0xffde, 0x4, 0x2, 0x2, 0x2b, 0x2d, 0x1, 0x5,
+ 0x2, 0x2, 0x28, 0x2a, 0x5d, 0x5f, 0x1, 0x5, 0x2, 0x2, 0xb, 0xd, 0xe,
+ 0x10, 0x1, 0x4, 0x2, 0x2, 0x30, 0x32, 0x1, 0x3, 0x2, 0x1f, 0x1f, 0x3,
+ 0x2, 0x1e, 0x1e, 0x3, 0x2, 0xf, 0xf, 0x13, 0x2, 0x26, 0x26, 0xa4, 0xa7,
+ 0x591, 0x591, 0x60d, 0x60d, 0x9f4, 0x9f5, 0x9fd, 0x9fd, 0xaf3, 0xaf3,
+ 0xbfb, 0xbfb, 0xe41, 0xe41, 0x17dd, 0x17dd, 0x20a2, 0x20bc, 0xa83a,
+ 0xa83a, 0xfdfe, 0xfdfe, 0xfe6b, 0xfe6b, 0xff06, 0xff06, 0xffe2, 0xffe3,
+ 0xffe7, 0xffe8, 0x3, 0x2, 0x22, 0x22, 0x3, 0x2, 0xb, 0xb, 0x5, 0x2,
+ 0x2, 0x23, 0x25, 0x5d, 0x5f, 0x1, 0x3, 0x2, 0xc, 0xc, 0x3, 0x2, 0xd,
+ 0xd, 0x3, 0x2, 0x21, 0x21, 0x174, 0x2, 0x43, 0x5c, 0x63, 0x7c, 0xac,
+ 0xac, 0xb7, 0xb7, 0xbc, 0xbc, 0xc2, 0xd8, 0xda, 0xf8, 0xfa, 0x2c3, 0x2c8,
+ 0x2d3, 0x2e2, 0x2e6, 0x2ee, 0x2ee, 0x2f0, 0x2f0, 0x372, 0x376, 0x378,
+ 0x379, 0x37c, 0x37f, 0x388, 0x388, 0x38a, 0x38c, 0x38e, 0x38e, 0x390,
+ 0x3a3, 0x3a5, 0x3f7, 0x3f9, 0x483, 0x48c, 0x529, 0x533, 0x558, 0x55b,
+ 0x55b, 0x563, 0x589, 0x5d2, 0x5ec, 0x5f2, 0x5f4, 0x622, 0x64c, 0x670,
+ 0x671, 0x673, 0x6d5, 0x6d7, 0x6d7, 0x6e7, 0x6e8, 0x6f0, 0x6f1, 0x6fc,
+ 0x6fe, 0x701, 0x701, 0x712, 0x712, 0x714, 0x731, 0x74f, 0x7a7, 0x7b3,
+ 0x7b3, 0x7cc, 0x7ec, 0x7f6, 0x7f7, 0x7fc, 0x7fc, 0x802, 0x817, 0x81c,
+ 0x81c, 0x826, 0x826, 0x82a, 0x82a, 0x842, 0x85a, 0x8a2, 0x8a2, 0x8a4,
+ 0x8ae, 0x906, 0x93b, 0x93f, 0x93f, 0x952, 0x952, 0x95a, 0x963, 0x973,
+ 0x979, 0x97b, 0x981, 0x987, 0x98e, 0x991, 0x992, 0x995, 0x9aa, 0x9ac,
+ 0x9b2, 0x9b4, 0x9b4, 0x9b8, 0x9bb, 0x9bf, 0x9bf, 0x9d0, 0x9d0, 0x9de,
+ 0x9df, 0x9e1, 0x9e3, 0x9f2, 0x9f3, 0xa07, 0xa0c, 0xa11, 0xa12, 0xa15,
+ 0xa2a, 0xa2c, 0xa32, 0xa34, 0xa35, 0xa37, 0xa38, 0xa3a, 0xa3b, 0xa5b,
+ 0xa5e, 0xa60, 0xa60, 0xa74, 0xa76, 0xa87, 0xa8f, 0xa91, 0xa93, 0xa95,
+ 0xaaa, 0xaac, 0xab2, 0xab4, 0xab5, 0xab7, 0xabb, 0xabf, 0xabf, 0xad2,
+ 0xad2, 0xae2, 0xae3, 0xb07, 0xb0e, 0xb11, 0xb12, 0xb15, 0xb2a, 0xb2c,
+ 0xb32, 0xb34, 0xb35, 0xb37, 0xb3b, 0xb3f, 0xb3f, 0xb5e, 0xb5f, 0xb61,
+ 0xb63, 0xb73, 0xb73, 0xb85, 0xb85, 0xb87, 0xb8c, 0xb90, 0xb92, 0xb94,
+ 0xb97, 0xb9b, 0xb9c, 0xb9e, 0xb9e, 0xba0, 0xba1, 0xba5, 0xba6, 0xbaa,
+ 0xbac, 0xbb0, 0xbbb, 0xbd2, 0xbd2, 0xc07, 0xc0e, 0xc10, 0xc12, 0xc14,
+ 0xc2a, 0xc2c, 0xc35, 0xc37, 0xc3b, 0xc3f, 0xc3f, 0xc5a, 0xc5b, 0xc62,
+ 0xc63, 0xc87, 0xc8e, 0xc90, 0xc92, 0xc94, 0xcaa, 0xcac, 0xcb5, 0xcb7,
+ 0xcbb, 0xcbf, 0xcbf, 0xce0, 0xce0, 0xce2, 0xce3, 0xcf3, 0xcf4, 0xd07,
+ 0xd0e, 0xd10, 0xd12, 0xd14, 0xd3c, 0xd3f, 0xd3f, 0xd50, 0xd50, 0xd62,
+ 0xd63, 0xd7c, 0xd81, 0xd87, 0xd98, 0xd9c, 0xdb3, 0xdb5, 0xdbd, 0xdbf,
+ 0xdbf, 0xdc2, 0xdc8, 0xe03, 0xe32, 0xe34, 0xe35, 0xe42, 0xe48, 0xe83,
+ 0xe84, 0xe86, 0xe86, 0xe89, 0xe8a, 0xe8c, 0xe8c, 0xe8f, 0xe8f, 0xe96,
+ 0xe99, 0xe9b, 0xea1, 0xea3, 0xea5, 0xea7, 0xea7, 0xea9, 0xea9, 0xeac,
+ 0xead, 0xeaf, 0xeb2, 0xeb4, 0xeb5, 0xebf, 0xebf, 0xec2, 0xec6, 0xec8,
+ 0xec8, 0xede, 0xee1, 0xf02, 0xf02, 0xf42, 0xf49, 0xf4b, 0xf6e, 0xf8a,
+ 0xf8e, 0x1002, 0x102c, 0x1041, 0x1041, 0x1052, 0x1057, 0x105c, 0x105f,
+ 0x1063, 0x1063, 0x1067, 0x1068, 0x1070, 0x1072, 0x1077, 0x1083, 0x1090,
+ 0x1090, 0x10a2, 0x10c7, 0x10c9, 0x10c9, 0x10cf, 0x10cf, 0x10d2, 0x10fc,
+ 0x10fe, 0x124a, 0x124c, 0x124f, 0x1252, 0x1258, 0x125a, 0x125a, 0x125c,
+ 0x125f, 0x1262, 0x128a, 0x128c, 0x128f, 0x1292, 0x12b2, 0x12b4, 0x12b7,
+ 0x12ba, 0x12c0, 0x12c2, 0x12c2, 0x12c4, 0x12c7, 0x12ca, 0x12d8, 0x12da,
+ 0x1312, 0x1314, 0x1317, 0x131a, 0x135c, 0x1382, 0x1391, 0x13a2, 0x13f6,
+ 0x1403, 0x166e, 0x1671, 0x1681, 0x1683, 0x169c, 0x16a2, 0x16ec, 0x16f0,
+ 0x16f2, 0x1702, 0x170e, 0x1710, 0x1713, 0x1722, 0x1733, 0x1742, 0x1753,
+ 0x1762, 0x176e, 0x1770, 0x1772, 0x1782, 0x17b5, 0x17d9, 0x17d9, 0x17de,
+ 0x17de, 0x1822, 0x1879, 0x1882, 0x18aa, 0x18ac, 0x18ac, 0x18b2, 0x18f7,
+ 0x1902, 0x191e, 0x1952, 0x196f, 0x1972, 0x1976, 0x1982, 0x19ad, 0x19c3,
+ 0x19c9, 0x1a02, 0x1a18, 0x1a22, 0x1a56, 0x1aa9, 0x1aa9, 0x1b07, 0x1b35,
+ 0x1b47, 0x1b4d, 0x1b85, 0x1ba2, 0x1bb0, 0x1bb1, 0x1bbc, 0x1be7, 0x1c02,
+ 0x1c25, 0x1c4f, 0x1c51, 0x1c5c, 0x1c7f, 0x1ceb, 0x1cee, 0x1cf0, 0x1cf3,
+ 0x1cf7, 0x1cf8, 0x1d02, 0x1dc1, 0x1e02, 0x1f17, 0x1f1a, 0x1f1f, 0x1f22,
+ 0x1f47, 0x1f4a, 0x1f4f, 0x1f52, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d,
+ 0x1f5f, 0x1f5f, 0x1f61, 0x1f7f, 0x1f82, 0x1fb6, 0x1fb8, 0x1fbe, 0x1fc0,
+ 0x1fc0, 0x1fc4, 0x1fc6, 0x1fc8, 0x1fce, 0x1fd2, 0x1fd5, 0x1fd8, 0x1fdd,
+ 0x1fe2, 0x1fee, 0x1ff4, 0x1ff6, 0x1ff8, 0x1ffe, 0x2073, 0x2073, 0x2081,
+ 0x2081, 0x2092, 0x209e, 0x2104, 0x2104, 0x2109, 0x2109, 0x210c, 0x2115,
+ 0x2117, 0x2117, 0x211a, 0x211f, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a,
+ 0x212a, 0x212c, 0x213b, 0x213e, 0x2141, 0x2147, 0x214b, 0x2150, 0x2150,
+ 0x2162, 0x218a, 0x2c02, 0x2c30, 0x2c32, 0x2c60, 0x2c62, 0x2ce6, 0x2ced,
+ 0x2cf0, 0x2cf4, 0x2cf5, 0x2d02, 0x2d27, 0x2d29, 0x2d29, 0x2d2f, 0x2d2f,
+ 0x2d32, 0x2d69, 0x2d71, 0x2d71, 0x2d82, 0x2d98, 0x2da2, 0x2da8, 0x2daa,
+ 0x2db0, 0x2db2, 0x2db8, 0x2dba, 0x2dc0, 0x2dc2, 0x2dc8, 0x2dca, 0x2dd0,
+ 0x2dd2, 0x2dd8, 0x2dda, 0x2de0, 0x3007, 0x3009, 0x3023, 0x302b, 0x3033,
+ 0x3037, 0x303a, 0x303e, 0x3043, 0x3098, 0x309d, 0x30a1, 0x30a3, 0x30fc,
+ 0x30fe, 0x3101, 0x3107, 0x312f, 0x3133, 0x3190, 0x31a2, 0x31bc, 0x31f2,
+ 0x3201, 0x3402, 0x4db7, 0x4e02, 0x9fce, 0xa002, 0xa48e, 0xa4d2, 0xa4ff,
+ 0xa502, 0xa60e, 0xa612, 0xa621, 0xa62c, 0xa62d, 0xa642, 0xa670, 0xa681,
+ 0xa699, 0xa6a2, 0xa6f1, 0xa719, 0xa721, 0xa724, 0xa78a, 0xa78d, 0xa790,
+ 0xa792, 0xa795, 0xa7a2, 0xa7ac, 0xa7fa, 0xa803, 0xa805, 0xa807, 0xa809,
+ 0xa80c, 0xa80e, 0xa824, 0xa842, 0xa875, 0xa884, 0xa8b5, 0xa8f4, 0xa8f9,
+ 0xa8fd, 0xa8fd, 0xa90c, 0xa927, 0xa932, 0xa948, 0xa962, 0xa97e, 0xa986,
+ 0xa9b4, 0xa9d1, 0xa9d1, 0xaa02, 0xaa2a, 0xaa42, 0xaa44, 0xaa46, 0xaa4d,
+ 0xaa62, 0xaa78, 0xaa7c, 0xaa7c, 0xaa82, 0xaab1, 0xaab3, 0xaab3, 0xaab7,
+ 0xaab8, 0xaabb, 0xaabf, 0xaac2, 0xaac2, 0xaac4, 0xaac4, 0xaadd, 0xaadf,
+ 0xaae2, 0xaaec, 0xaaf4, 0xaaf6, 0xab03, 0xab08, 0xab0b, 0xab10, 0xab13,
+ 0xab18, 0xab22, 0xab28, 0xab2a, 0xab30, 0xabc2, 0xabe4, 0xac02, 0xd7a5,
+ 0xd7b2, 0xd7c8, 0xd7cd, 0xd7fd, 0xf902, 0xfa6f, 0xfa72, 0xfadb, 0xfb02,
+ 0xfb08, 0xfb15, 0xfb19, 0xfb1f, 0xfb1f, 0xfb21, 0xfb2a, 0xfb2c, 0xfb38,
+ 0xfb3a, 0xfb3e, 0xfb40, 0xfb40, 0xfb42, 0xfb43, 0xfb45, 0xfb46, 0xfb48,
+ 0xfbb3, 0xfbd5, 0xfd3f, 0xfd52, 0xfd91, 0xfd94, 0xfdc9, 0xfdf2, 0xfdfd,
+ 0xfe72, 0xfe76, 0xfe78, 0xfefe, 0xff23, 0xff3c, 0xff43, 0xff5c, 0xff68,
+ 0xffc0, 0xffc4, 0xffc9, 0xffcc, 0xffd1, 0xffd4, 0xffd9, 0xffdc, 0xffde,
+ 0x379, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2,
+ 0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb, 0x3,
+ 0x2, 0x2, 0x2, 0x2, 0xd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf, 0x3, 0x2, 0x2,
+ 0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x2, 0x13, 0x3, 0x2, 0x2, 0x2, 0x2,
+ 0x15, 0x3, 0x2, 0x2, 0x2, 0x2, 0x17, 0x3, 0x2, 0x2, 0x2, 0x2, 0x19,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1d, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x21, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x23, 0x3, 0x2, 0x2, 0x2, 0x2, 0x25, 0x3, 0x2, 0x2, 0x2, 0x2, 0x27,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x29, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2b, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2f, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x31, 0x3, 0x2, 0x2, 0x2, 0x2, 0x33, 0x3, 0x2, 0x2, 0x2, 0x2, 0x35,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x37, 0x3, 0x2, 0x2, 0x2, 0x2, 0x39, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3d, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x41, 0x3, 0x2, 0x2, 0x2, 0x2, 0x43,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x45, 0x3, 0x2, 0x2, 0x2, 0x2, 0x47, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x49, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4b, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x51,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x53, 0x3, 0x2, 0x2, 0x2, 0x2, 0x55, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x57, 0x3, 0x2, 0x2, 0x2, 0x2, 0x59, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5f,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x61, 0x3, 0x2, 0x2, 0x2, 0x2, 0x63, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x65, 0x3, 0x2, 0x2, 0x2, 0x2, 0x67, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x69, 0x3, 0x2, 0x2, 0x2, 0x2, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x6d,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x71, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x73, 0x3, 0x2, 0x2, 0x2, 0x2, 0x75, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x77, 0x3, 0x2, 0x2, 0x2, 0x2, 0x79, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7b,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7f, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x81, 0x3, 0x2, 0x2, 0x2, 0x2, 0x83, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x85, 0x3, 0x2, 0x2, 0x2, 0x2, 0x87, 0x3, 0x2, 0x2, 0x2, 0x2, 0x89,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x2, 0x8d, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x2, 0x91, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0x93, 0x3, 0x2, 0x2, 0x2, 0x2, 0x95, 0x3, 0x2, 0x2, 0x2, 0x2, 0x97,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0x99, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9b, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9f, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0xa1, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa5,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0xa7, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa9, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0xab, 0x3, 0x2, 0x2, 0x2, 0x2, 0xad, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb1, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb3,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0xb5, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb7, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0xb9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xbb, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xbf, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc1,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0xc3, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc5, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc9, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0xcb, 0x3, 0x2, 0x2, 0x2, 0x2, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xcf,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0xd1, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd3, 0x3, 0x2,
+ 0x2, 0x2, 0x2, 0xd5, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd7, 0x3, 0x2, 0x2, 0x2,
+ 0x2, 0xd9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xdb, 0x3, 0x2, 0x2, 0x2, 0x2, 0xdd,
+ 0x3, 0x2, 0x2, 0x2, 0x2, 0xdf, 0x3, 0x2, 0x2, 0x2, 0x3, 0x107, 0x3,
+ 0x2, 0x2, 0x2, 0x5, 0x109, 0x3, 0x2, 0x2, 0x2, 0x7, 0x10b, 0x3, 0x2,
+ 0x2, 0x2, 0x9, 0x10d, 0x3, 0x2, 0x2, 0x2, 0xb, 0x110, 0x3, 0x2, 0x2,
+ 0x2, 0xd, 0x112, 0x3, 0x2, 0x2, 0x2, 0xf, 0x114, 0x3, 0x2, 0x2, 0x2,
+ 0x11, 0x116, 0x3, 0x2, 0x2, 0x2, 0x13, 0x118, 0x3, 0x2, 0x2, 0x2, 0x15,
+ 0x11a, 0x3, 0x2, 0x2, 0x2, 0x17, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x19, 0x11e,
+ 0x3, 0x2, 0x2, 0x2, 0x1b, 0x121, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x123, 0x3,
+ 0x2, 0x2, 0x2, 0x1f, 0x125, 0x3, 0x2, 0x2, 0x2, 0x21, 0x127, 0x3, 0x2,
+ 0x2, 0x2, 0x23, 0x129, 0x3, 0x2, 0x2, 0x2, 0x25, 0x12b, 0x3, 0x2, 0x2,
+ 0x2, 0x27, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x29, 0x131, 0x3, 0x2, 0x2, 0x2,
+ 0x2b, 0x134, 0x3, 0x2, 0x2, 0x2, 0x2d, 0x136, 0x3, 0x2, 0x2, 0x2, 0x2f,
+ 0x138, 0x3, 0x2, 0x2, 0x2, 0x31, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x33, 0x13e,
+ 0x3, 0x2, 0x2, 0x2, 0x35, 0x140, 0x3, 0x2, 0x2, 0x2, 0x37, 0x142, 0x3,
+ 0x2, 0x2, 0x2, 0x39, 0x144, 0x3, 0x2, 0x2, 0x2, 0x3b, 0x146, 0x3, 0x2,
+ 0x2, 0x2, 0x3d, 0x148, 0x3, 0x2, 0x2, 0x2, 0x3f, 0x14a, 0x3, 0x2, 0x2,
+ 0x2, 0x41, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x43, 0x14e, 0x3, 0x2, 0x2, 0x2,
+ 0x45, 0x150, 0x3, 0x2, 0x2, 0x2, 0x47, 0x152, 0x3, 0x2, 0x2, 0x2, 0x49,
+ 0x154, 0x3, 0x2, 0x2, 0x2, 0x4b, 0x156, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x158,
+ 0x3, 0x2, 0x2, 0x2, 0x4f, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x51, 0x15c, 0x3,
+ 0x2, 0x2, 0x2, 0x53, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x55, 0x160, 0x3, 0x2,
+ 0x2, 0x2, 0x57, 0x162, 0x3, 0x2, 0x2, 0x2, 0x59, 0x164, 0x3, 0x2, 0x2,
+ 0x2, 0x5b, 0x166, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x168, 0x3, 0x2, 0x2, 0x2,
+ 0x5f, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x61, 0x17e, 0x3, 0x2, 0x2, 0x2, 0x63,
+ 0x180, 0x3, 0x2, 0x2, 0x2, 0x65, 0x194, 0x3, 0x2, 0x2, 0x2, 0x67, 0x1a4,
+ 0x3, 0x2, 0x2, 0x2, 0x69, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x6b, 0x1ad, 0x3,
+ 0x2, 0x2, 0x2, 0x6d, 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x6f, 0x1b5, 0x3, 0x2,
+ 0x2, 0x2, 0x71, 0x1b9, 0x3, 0x2, 0x2, 0x2, 0x73, 0x1bb, 0x3, 0x2, 0x2,
+ 0x2, 0x75, 0x1bf, 0x3, 0x2, 0x2, 0x2, 0x77, 0x1c1, 0x3, 0x2, 0x2, 0x2,
+ 0x79, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x7b, 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x7d,
+ 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x1f8, 0x3, 0x2, 0x2, 0x2, 0x81, 0x1fc,
+ 0x3, 0x2, 0x2, 0x2, 0x83, 0x205, 0x3, 0x2, 0x2, 0x2, 0x85, 0x20b, 0x3,
+ 0x2, 0x2, 0x2, 0x87, 0x212, 0x3, 0x2, 0x2, 0x2, 0x89, 0x215, 0x3, 0x2,
+ 0x2, 0x2, 0x8b, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x8d, 0x21e, 0x3, 0x2, 0x2,
+ 0x2, 0x8f, 0x225, 0x3, 0x2, 0x2, 0x2, 0x91, 0x229, 0x3, 0x2, 0x2, 0x2,
+ 0x93, 0x230, 0x3, 0x2, 0x2, 0x2, 0x95, 0x237, 0x3, 0x2, 0x2, 0x2, 0x97,
+ 0x23e, 0x3, 0x2, 0x2, 0x2, 0x99, 0x243, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x24c,
+ 0x3, 0x2, 0x2, 0x2, 0x9d, 0x253, 0x3, 0x2, 0x2, 0x2, 0x9f, 0x259, 0x3,
+ 0x2, 0x2, 0x2, 0xa1, 0x25c, 0x3, 0x2, 0x2, 0x2, 0xa3, 0x261, 0x3, 0x2,
+ 0x2, 0x2, 0xa5, 0x267, 0x3, 0x2, 0x2, 0x2, 0xa7, 0x271, 0x3, 0x2, 0x2,
+ 0x2, 0xa9, 0x275, 0x3, 0x2, 0x2, 0x2, 0xab, 0x280, 0x3, 0x2, 0x2, 0x2,
+ 0xad, 0x285, 0x3, 0x2, 0x2, 0x2, 0xaf, 0x28b, 0x3, 0x2, 0x2, 0x2, 0xb1,
+ 0x28e, 0x3, 0x2, 0x2, 0x2, 0xb3, 0x292, 0x3, 0x2, 0x2, 0x2, 0xb5, 0x296,
+ 0x3, 0x2, 0x2, 0x2, 0xb7, 0x29a, 0x3, 0x2, 0x2, 0x2, 0xb9, 0x29d, 0x3,
+ 0x2, 0x2, 0x2, 0xbb, 0x2a4, 0x3, 0x2, 0x2, 0x2, 0xbd, 0x2a9, 0x3, 0x2,
+ 0x2, 0x2, 0xbf, 0x2b2, 0x3, 0x2, 0x2, 0x2, 0xc1, 0x2b5, 0x3, 0x2, 0x2,
+ 0x2, 0xc3, 0x2ba, 0x3, 0x2, 0x2, 0x2, 0xc5, 0x2c0, 0x3, 0x2, 0x2, 0x2,
+ 0xc7, 0x2c7, 0x3, 0x2, 0x2, 0x2, 0xc9, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0xcb,
+ 0x2d3, 0x3, 0x2, 0x2, 0x2, 0xcd, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0xcf, 0x2df,
+ 0x3, 0x2, 0x2, 0x2, 0xd1, 0x2e4, 0x3, 0x2, 0x2, 0x2, 0xd3, 0x2ea, 0x3,
+ 0x2, 0x2, 0x2, 0xd5, 0x2f3, 0x3, 0x2, 0x2, 0x2, 0xd7, 0x2f7, 0x3, 0x2,
+ 0x2, 0x2, 0xd9, 0x301, 0x3, 0x2, 0x2, 0x2, 0xdb, 0x306, 0x3, 0x2, 0x2,
+ 0x2, 0xdd, 0x316, 0x3, 0x2, 0x2, 0x2, 0xdf, 0x335, 0x3, 0x2, 0x2, 0x2,
+ 0xe1, 0x337, 0x3, 0x2, 0x2, 0x2, 0xe3, 0x339, 0x3, 0x2, 0x2, 0x2, 0xe5,
+ 0x33b, 0x3, 0x2, 0x2, 0x2, 0xe7, 0x33d, 0x3, 0x2, 0x2, 0x2, 0xe9, 0x33f,
+ 0x3, 0x2, 0x2, 0x2, 0xeb, 0x341, 0x3, 0x2, 0x2, 0x2, 0xed, 0x343, 0x3,
+ 0x2, 0x2, 0x2, 0xef, 0x345, 0x3, 0x2, 0x2, 0x2, 0xf1, 0x347, 0x3, 0x2,
+ 0x2, 0x2, 0xf3, 0x349, 0x3, 0x2, 0x2, 0x2, 0xf5, 0x34b, 0x3, 0x2, 0x2,
+ 0x2, 0xf7, 0x34d, 0x3, 0x2, 0x2, 0x2, 0xf9, 0x34f, 0x3, 0x2, 0x2, 0x2,
+ 0xfb, 0x351, 0x3, 0x2, 0x2, 0x2, 0xfd, 0x353, 0x3, 0x2, 0x2, 0x2, 0xff,
+ 0x355, 0x3, 0x2, 0x2, 0x2, 0x101, 0x357, 0x3, 0x2, 0x2, 0x2, 0x103,
+ 0x359, 0x3, 0x2, 0x2, 0x2, 0x105, 0x35b, 0x3, 0x2, 0x2, 0x2, 0x107,
+ 0x108, 0x7, 0x3d, 0x2, 0x2, 0x108, 0x4, 0x3, 0x2, 0x2, 0x2, 0x109, 0x10a,
+ 0x7, 0x2e, 0x2, 0x2, 0x10a, 0x6, 0x3, 0x2, 0x2, 0x2, 0x10b, 0x10c, 0x7,
+ 0x3f, 0x2, 0x2, 0x10c, 0x8, 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10e, 0x7, 0x2d,
+ 0x2, 0x2, 0x10e, 0x10f, 0x7, 0x3f, 0x2, 0x2, 0x10f, 0xa, 0x3, 0x2, 0x2,
+ 0x2, 0x110, 0x111, 0x7, 0x2c, 0x2, 0x2, 0x111, 0xc, 0x3, 0x2, 0x2, 0x2,
+ 0x112, 0x113, 0x7, 0x2a, 0x2, 0x2, 0x113, 0xe, 0x3, 0x2, 0x2, 0x2, 0x114,
+ 0x115, 0x7, 0x2b, 0x2, 0x2, 0x115, 0x10, 0x3, 0x2, 0x2, 0x2, 0x116,
+ 0x117, 0x7, 0x5d, 0x2, 0x2, 0x117, 0x12, 0x3, 0x2, 0x2, 0x2, 0x118,
+ 0x119, 0x7, 0x5f, 0x2, 0x2, 0x119, 0x14, 0x3, 0x2, 0x2, 0x2, 0x11a,
+ 0x11b, 0x7, 0x3c, 0x2, 0x2, 0x11b, 0x16, 0x3, 0x2, 0x2, 0x2, 0x11c,
+ 0x11d, 0x7, 0x7e, 0x2, 0x2, 0x11d, 0x18, 0x3, 0x2, 0x2, 0x2, 0x11e,
+ 0x11f, 0x7, 0x30, 0x2, 0x2, 0x11f, 0x120, 0x7, 0x30, 0x2, 0x2, 0x120,
+ 0x1a, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, 0x7, 0x2d, 0x2, 0x2, 0x122,
+ 0x1c, 0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x7, 0x2f, 0x2, 0x2, 0x124,
+ 0x1e, 0x3, 0x2, 0x2, 0x2, 0x125, 0x126, 0x7, 0x31, 0x2, 0x2, 0x126,
+ 0x20, 0x3, 0x2, 0x2, 0x2, 0x127, 0x128, 0x7, 0x27, 0x2, 0x2, 0x128,
+ 0x22, 0x3, 0x2, 0x2, 0x2, 0x129, 0x12a, 0x7, 0x60, 0x2, 0x2, 0x12a,
+ 0x24, 0x3, 0x2, 0x2, 0x2, 0x12b, 0x12c, 0x7, 0x3f, 0x2, 0x2, 0x12c,
+ 0x12d, 0x7, 0x80, 0x2, 0x2, 0x12d, 0x26, 0x3, 0x2, 0x2, 0x2, 0x12e,
+ 0x12f, 0x7, 0x3e, 0x2, 0x2, 0x12f, 0x130, 0x7, 0x40, 0x2, 0x2, 0x130,
+ 0x28, 0x3, 0x2, 0x2, 0x2, 0x131, 0x132, 0x7, 0x23, 0x2, 0x2, 0x132,
+ 0x133, 0x7, 0x3f, 0x2, 0x2, 0x133, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x134,
+ 0x135, 0x7, 0x3e, 0x2, 0x2, 0x135, 0x2c, 0x3, 0x2, 0x2, 0x2, 0x136,
+ 0x137, 0x7, 0x40, 0x2, 0x2, 0x137, 0x2e, 0x3, 0x2, 0x2, 0x2, 0x138,
+ 0x139, 0x7, 0x3e, 0x2, 0x2, 0x139, 0x13a, 0x7, 0x3f, 0x2, 0x2, 0x13a,
+ 0x30, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13c, 0x7, 0x40, 0x2, 0x2, 0x13c,
+ 0x13d, 0x7, 0x3f, 0x2, 0x2, 0x13d, 0x32, 0x3, 0x2, 0x2, 0x2, 0x13e,
+ 0x13f, 0x7, 0x30, 0x2, 0x2, 0x13f, 0x34, 0x3, 0x2, 0x2, 0x2, 0x140,
+ 0x141, 0x7, 0x7d, 0x2, 0x2, 0x141, 0x36, 0x3, 0x2, 0x2, 0x2, 0x142,
+ 0x143, 0x7, 0x7f, 0x2, 0x2, 0x143, 0x38, 0x3, 0x2, 0x2, 0x2, 0x144,
+ 0x145, 0x7, 0x26, 0x2, 0x2, 0x145, 0x3a, 0x3, 0x2, 0x2, 0x2, 0x146,
+ 0x147, 0x7, 0x27ea, 0x2, 0x2, 0x147, 0x3c, 0x3, 0x2, 0x2, 0x2, 0x148,
+ 0x149, 0x7, 0x300a, 0x2, 0x2, 0x149, 0x3e, 0x3, 0x2, 0x2, 0x2, 0x14a,
+ 0x14b, 0x7, 0xfe66, 0x2, 0x2, 0x14b, 0x40, 0x3, 0x2, 0x2, 0x2, 0x14c,
+ 0x14d, 0x7, 0xff1e, 0x2, 0x2, 0x14d, 0x42, 0x3, 0x2, 0x2, 0x2, 0x14e,
+ 0x14f, 0x7, 0x27eb, 0x2, 0x2, 0x14f, 0x44, 0x3, 0x2, 0x2, 0x2, 0x150,
+ 0x151, 0x7, 0x300b, 0x2, 0x2, 0x151, 0x46, 0x3, 0x2, 0x2, 0x2, 0x152,
+ 0x153, 0x7, 0xfe67, 0x2, 0x2, 0x153, 0x48, 0x3, 0x2, 0x2, 0x2, 0x154,
+ 0x155, 0x7, 0xff20, 0x2, 0x2, 0x155, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x156,
+ 0x157, 0x7, 0xaf, 0x2, 0x2, 0x157, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x158,
+ 0x159, 0x7, 0x2012, 0x2, 0x2, 0x159, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x15a,
+ 0x15b, 0x7, 0x2013, 0x2, 0x2, 0x15b, 0x50, 0x3, 0x2, 0x2, 0x2, 0x15c,
+ 0x15d, 0x7, 0x2014, 0x2, 0x2, 0x15d, 0x52, 0x3, 0x2, 0x2, 0x2, 0x15e,
+ 0x15f, 0x7, 0x2015, 0x2, 0x2, 0x15f, 0x54, 0x3, 0x2, 0x2, 0x2, 0x160,
+ 0x161, 0x7, 0x2016, 0x2, 0x2, 0x161, 0x56, 0x3, 0x2, 0x2, 0x2, 0x162,
+ 0x163, 0x7, 0x2017, 0x2, 0x2, 0x163, 0x58, 0x3, 0x2, 0x2, 0x2, 0x164,
+ 0x165, 0x7, 0x2214, 0x2, 0x2, 0x165, 0x5a, 0x3, 0x2, 0x2, 0x2, 0x166,
+ 0x167, 0x7, 0xfe5a, 0x2, 0x2, 0x167, 0x5c, 0x3, 0x2, 0x2, 0x2, 0x168,
+ 0x169, 0x7, 0xfe65, 0x2, 0x2, 0x169, 0x5e, 0x3, 0x2, 0x2, 0x2, 0x16a,
+ 0x16b, 0x7, 0xff0f, 0x2, 0x2, 0x16b, 0x60, 0x3, 0x2, 0x2, 0x2, 0x16c,
+ 0x171, 0x7, 0x24, 0x2, 0x2, 0x16d, 0x170, 0x5, 0xfd, 0x7f, 0x2, 0x16e,
+ 0x170, 0x5, 0x63, 0x32, 0x2, 0x16f, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x16f,
+ 0x16e, 0x3, 0x2, 0x2, 0x2, 0x170, 0x173, 0x3, 0x2, 0x2, 0x2, 0x171,
+ 0x16f, 0x3, 0x2, 0x2, 0x2, 0x171, 0x172, 0x3, 0x2, 0x2, 0x2, 0x172,
+ 0x174, 0x3, 0x2, 0x2, 0x2, 0x173, 0x171, 0x3, 0x2, 0x2, 0x2, 0x174,
+ 0x17f, 0x7, 0x24, 0x2, 0x2, 0x175, 0x17a, 0x7, 0x29, 0x2, 0x2, 0x176,
+ 0x179, 0x5, 0xeb, 0x76, 0x2, 0x177, 0x179, 0x5, 0x63, 0x32, 0x2, 0x178,
+ 0x176, 0x3, 0x2, 0x2, 0x2, 0x178, 0x177, 0x3, 0x2, 0x2, 0x2, 0x179,
+ 0x17c, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x178, 0x3, 0x2, 0x2, 0x2, 0x17a,
+ 0x17b, 0x3, 0x2, 0x2, 0x2, 0x17b, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x17c,
+ 0x17a, 0x3, 0x2, 0x2, 0x2, 0x17d, 0x17f, 0x7, 0x29, 0x2, 0x2, 0x17e,
+ 0x16c, 0x3, 0x2, 0x2, 0x2, 0x17e, 0x175, 0x3, 0x2, 0x2, 0x2, 0x17f,
+ 0x62, 0x3, 0x2, 0x2, 0x2, 0x180, 0x192, 0x7, 0x5e, 0x2, 0x2, 0x181,
+ 0x193, 0x9, 0x2, 0x2, 0x2, 0x182, 0x183, 0x9, 0x3, 0x2, 0x2, 0x183,
+ 0x184, 0x5, 0x6d, 0x37, 0x2, 0x184, 0x185, 0x5, 0x6d, 0x37, 0x2, 0x185,
+ 0x186, 0x5, 0x6d, 0x37, 0x2, 0x186, 0x187, 0x5, 0x6d, 0x37, 0x2, 0x187,
+ 0x193, 0x3, 0x2, 0x2, 0x2, 0x188, 0x189, 0x9, 0x3, 0x2, 0x2, 0x189,
+ 0x18a, 0x5, 0x6d, 0x37, 0x2, 0x18a, 0x18b, 0x5, 0x6d, 0x37, 0x2, 0x18b,
+ 0x18c, 0x5, 0x6d, 0x37, 0x2, 0x18c, 0x18d, 0x5, 0x6d, 0x37, 0x2, 0x18d,
+ 0x18e, 0x5, 0x6d, 0x37, 0x2, 0x18e, 0x18f, 0x5, 0x6d, 0x37, 0x2, 0x18f,
+ 0x190, 0x5, 0x6d, 0x37, 0x2, 0x190, 0x191, 0x5, 0x6d, 0x37, 0x2, 0x191,
+ 0x193, 0x3, 0x2, 0x2, 0x2, 0x192, 0x181, 0x3, 0x2, 0x2, 0x2, 0x192,
+ 0x182, 0x3, 0x2, 0x2, 0x2, 0x192, 0x188, 0x3, 0x2, 0x2, 0x2, 0x193,
+ 0x64, 0x3, 0x2, 0x2, 0x2, 0x194, 0x195, 0x7, 0x32, 0x2, 0x2, 0x195,
+ 0x196, 0x7, 0x7a, 0x2, 0x2, 0x196, 0x198, 0x3, 0x2, 0x2, 0x2, 0x197,
+ 0x199, 0x5, 0x6d, 0x37, 0x2, 0x198, 0x197, 0x3, 0x2, 0x2, 0x2, 0x199,
+ 0x19a, 0x3, 0x2, 0x2, 0x2, 0x19a, 0x198, 0x3, 0x2, 0x2, 0x2, 0x19a,
+ 0x19b, 0x3, 0x2, 0x2, 0x2, 0x19b, 0x66, 0x3, 0x2, 0x2, 0x2, 0x19c, 0x1a5,
+ 0x5, 0x77, 0x3c, 0x2, 0x19d, 0x1a1, 0x5, 0x71, 0x39, 0x2, 0x19e, 0x1a0,
+ 0x5, 0x6f, 0x38, 0x2, 0x19f, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x1a0, 0x1a3,
+ 0x3, 0x2, 0x2, 0x2, 0x1a1, 0x19f, 0x3, 0x2, 0x2, 0x2, 0x1a1, 0x1a2,
+ 0x3, 0x2, 0x2, 0x2, 0x1a2, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x1a1,
+ 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x19c, 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x19d,
+ 0x3, 0x2, 0x2, 0x2, 0x1a5, 0x68, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1a8, 0x5,
+ 0x77, 0x3c, 0x2, 0x1a7, 0x1a9, 0x5, 0x75, 0x3b, 0x2, 0x1a8, 0x1a7, 0x3,
+ 0x2, 0x2, 0x2, 0x1a9, 0x1aa, 0x3, 0x2, 0x2, 0x2, 0x1aa, 0x1a8, 0x3,
+ 0x2, 0x2, 0x2, 0x1aa, 0x1ab, 0x3, 0x2, 0x2, 0x2, 0x1ab, 0x6a, 0x3, 0x2,
+ 0x2, 0x2, 0x1ac, 0x1ae, 0x9, 0x4, 0x2, 0x2, 0x1ad, 0x1ac, 0x3, 0x2,
+ 0x2, 0x2, 0x1ae, 0x6c, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b2, 0x5, 0x6f,
+ 0x38, 0x2, 0x1b0, 0x1b2, 0x5, 0x6b, 0x36, 0x2, 0x1b1, 0x1af, 0x3, 0x2,
+ 0x2, 0x2, 0x1b1, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b2, 0x6e, 0x3, 0x2, 0x2,
+ 0x2, 0x1b3, 0x1b6, 0x5, 0x77, 0x3c, 0x2, 0x1b4, 0x1b6, 0x5, 0x71, 0x39,
+ 0x2, 0x1b5, 0x1b3, 0x3, 0x2, 0x2, 0x2, 0x1b5, 0x1b4, 0x3, 0x2, 0x2,
+ 0x2, 0x1b6, 0x70, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1ba, 0x5, 0x73, 0x3a,
+ 0x2, 0x1b8, 0x1ba, 0x4, 0x3a, 0x3b, 0x2, 0x1b9, 0x1b7, 0x3, 0x2, 0x2,
+ 0x2, 0x1b9, 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1ba, 0x72, 0x3, 0x2, 0x2, 0x2,
+ 0x1bb, 0x1bc, 0x4, 0x33, 0x39, 0x2, 0x1bc, 0x74, 0x3, 0x2, 0x2, 0x2,
+ 0x1bd, 0x1c0, 0x5, 0x77, 0x3c, 0x2, 0x1be, 0x1c0, 0x5, 0x73, 0x3a, 0x2,
+ 0x1bf, 0x1bd, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1be, 0x3, 0x2, 0x2, 0x2,
+ 0x1c0, 0x76, 0x3, 0x2, 0x2, 0x2, 0x1c1, 0x1c2, 0x7, 0x32, 0x2, 0x2,
+ 0x1c2, 0x78, 0x3, 0x2, 0x2, 0x2, 0x1c3, 0x1c5, 0x5, 0x6f, 0x38, 0x2,
+ 0x1c4, 0x1c3, 0x3, 0x2, 0x2, 0x2, 0x1c5, 0x1c6, 0x3, 0x2, 0x2, 0x2,
+ 0x1c6, 0x1c4, 0x3, 0x2, 0x2, 0x2, 0x1c6, 0x1c7, 0x3, 0x2, 0x2, 0x2,
+ 0x1c7, 0x1da, 0x3, 0x2, 0x2, 0x2, 0x1c8, 0x1ca, 0x5, 0x6f, 0x38, 0x2,
+ 0x1c9, 0x1c8, 0x3, 0x2, 0x2, 0x2, 0x1ca, 0x1cb, 0x3, 0x2, 0x2, 0x2,
+ 0x1cb, 0x1c9, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1cc, 0x3, 0x2, 0x2, 0x2,
+ 0x1cc, 0x1cd, 0x3, 0x2, 0x2, 0x2, 0x1cd, 0x1cf, 0x7, 0x30, 0x2, 0x2,
+ 0x1ce, 0x1d0, 0x5, 0x6f, 0x38, 0x2, 0x1cf, 0x1ce, 0x3, 0x2, 0x2, 0x2,
+ 0x1d0, 0x1d1, 0x3, 0x2, 0x2, 0x2, 0x1d1, 0x1cf, 0x3, 0x2, 0x2, 0x2,
+ 0x1d1, 0x1d2, 0x3, 0x2, 0x2, 0x2, 0x1d2, 0x1da, 0x3, 0x2, 0x2, 0x2,
+ 0x1d3, 0x1d5, 0x7, 0x30, 0x2, 0x2, 0x1d4, 0x1d6, 0x5, 0x6f, 0x38, 0x2,
+ 0x1d5, 0x1d4, 0x3, 0x2, 0x2, 0x2, 0x1d6, 0x1d7, 0x3, 0x2, 0x2, 0x2,
+ 0x1d7, 0x1d5, 0x3, 0x2, 0x2, 0x2, 0x1d7, 0x1d8, 0x3, 0x2, 0x2, 0x2,
+ 0x1d8, 0x1da, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1c4, 0x3, 0x2, 0x2, 0x2,
+ 0x1d9, 0x1c9, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1d3, 0x3, 0x2, 0x2, 0x2,
+ 0x1da, 0x1dc, 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dd, 0x9, 0x5, 0x2, 0x2,
+ 0x1dc, 0x1db, 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1df, 0x3, 0x2, 0x2, 0x2,
+ 0x1de, 0x1e0, 0x7, 0x2f, 0x2, 0x2, 0x1df, 0x1de, 0x3, 0x2, 0x2, 0x2,
+ 0x1df, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1e0, 0x1e2, 0x3, 0x2, 0x2, 0x2,
+ 0x1e1, 0x1e3, 0x5, 0x6f, 0x38, 0x2, 0x1e2, 0x1e1, 0x3, 0x2, 0x2, 0x2,
+ 0x1e3, 0x1e4, 0x3, 0x2, 0x2, 0x2, 0x1e4, 0x1e2, 0x3, 0x2, 0x2, 0x2,
+ 0x1e4, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e5, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x1e6,
+ 0x1e8, 0x5, 0x6f, 0x38, 0x2, 0x1e7, 0x1e6, 0x3, 0x2, 0x2, 0x2, 0x1e8,
+ 0x1eb, 0x3, 0x2, 0x2, 0x2, 0x1e9, 0x1e7, 0x3, 0x2, 0x2, 0x2, 0x1e9,
+ 0x1ea, 0x3, 0x2, 0x2, 0x2, 0x1ea, 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x1eb,
+ 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x1ec, 0x1ee, 0x7, 0x30, 0x2, 0x2, 0x1ed,
+ 0x1ef, 0x5, 0x6f, 0x38, 0x2, 0x1ee, 0x1ed, 0x3, 0x2, 0x2, 0x2, 0x1ef,
+ 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x1ee, 0x3, 0x2, 0x2, 0x2, 0x1f0,
+ 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x1f1, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f3,
+ 0x9, 0x3, 0x2, 0x2, 0x1f3, 0x1f4, 0x9, 0x6, 0x2, 0x2, 0x1f4, 0x1f5,
+ 0x9, 0x7, 0x2, 0x2, 0x1f5, 0x1f6, 0x9, 0x8, 0x2, 0x2, 0x1f6, 0x1f7,
+ 0x9, 0x6, 0x2, 0x2, 0x1f7, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f9, 0x9,
+ 0x9, 0x2, 0x2, 0x1f9, 0x1fa, 0x9, 0xa, 0x2, 0x2, 0x1fa, 0x1fb, 0x9,
+ 0xa, 0x2, 0x2, 0x1fb, 0x80, 0x3, 0x2, 0x2, 0x2, 0x1fc, 0x1fd, 0x9, 0x8,
+ 0x2, 0x2, 0x1fd, 0x1fe, 0x9, 0xb, 0x2, 0x2, 0x1fe, 0x1ff, 0x9, 0xc,
+ 0x2, 0x2, 0x1ff, 0x200, 0x9, 0x7, 0x2, 0x2, 0x200, 0x201, 0x9, 0x8,
+ 0x2, 0x2, 0x201, 0x202, 0x9, 0x6, 0x2, 0x2, 0x202, 0x203, 0x9, 0x9,
+ 0x2, 0x2, 0x203, 0x204, 0x9, 0xa, 0x2, 0x2, 0x204, 0x82, 0x3, 0x2, 0x2,
+ 0x2, 0x205, 0x206, 0x9, 0xd, 0x2, 0x2, 0x206, 0x207, 0x9, 0x9, 0x2,
+ 0x2, 0x207, 0x208, 0x9, 0xc, 0x2, 0x2, 0x208, 0x209, 0x9, 0xe, 0x2,
+ 0x2, 0x209, 0x20a, 0x9, 0xf, 0x2, 0x2, 0x20a, 0x84, 0x3, 0x2, 0x2, 0x2,
+ 0x20b, 0x20c, 0x9, 0x3, 0x2, 0x2, 0x20c, 0x20d, 0x9, 0x6, 0x2, 0x2,
+ 0x20d, 0x20e, 0x9, 0x10, 0x2, 0x2, 0x20e, 0x20f, 0x9, 0x7, 0x2, 0x2,
+ 0x20f, 0x210, 0x9, 0x6, 0x2, 0x2, 0x210, 0x211, 0x9, 0x11, 0x2, 0x2,
+ 0x211, 0x86, 0x3, 0x2, 0x2, 0x2, 0x212, 0x213, 0x9, 0x9, 0x2, 0x2, 0x213,
+ 0x214, 0x9, 0x12, 0x2, 0x2, 0x214, 0x88, 0x3, 0x2, 0x2, 0x2, 0x215,
+ 0x216, 0x9, 0xd, 0x2, 0x2, 0x216, 0x217, 0x9, 0x5, 0x2, 0x2, 0x217,
+ 0x218, 0x9, 0x13, 0x2, 0x2, 0x218, 0x219, 0x9, 0x14, 0x2, 0x2, 0x219,
+ 0x21a, 0x9, 0x5, 0x2, 0x2, 0x21a, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x21b, 0x21c,
+ 0x9, 0x8, 0x2, 0x2, 0x21c, 0x21d, 0x9, 0x6, 0x2, 0x2, 0x21d, 0x8c, 0x3,
+ 0x2, 0x2, 0x2, 0x21e, 0x21f, 0x9, 0xe, 0x2, 0x2, 0x21f, 0x220, 0x9,
+ 0x13, 0x2, 0x2, 0x220, 0x221, 0x9, 0x5, 0x2, 0x2, 0x221, 0x222, 0x9,
+ 0x9, 0x2, 0x2, 0x222, 0x223, 0x9, 0xc, 0x2, 0x2, 0x223, 0x224, 0x9,
+ 0x5, 0x2, 0x2, 0x224, 0x8e, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x9, 0x12,
+ 0x2, 0x2, 0x226, 0x227, 0x9, 0x5, 0x2, 0x2, 0x227, 0x228, 0x9, 0xc,
+ 0x2, 0x2, 0x228, 0x90, 0x3, 0x2, 0x2, 0x2, 0x229, 0x22a, 0x9, 0x11,
+ 0x2, 0x2, 0x22a, 0x22b, 0x9, 0x5, 0x2, 0x2, 0x22b, 0x22c, 0x9, 0xc,
+ 0x2, 0x2, 0x22c, 0x22d, 0x9, 0x9, 0x2, 0x2, 0x22d, 0x22e, 0x9, 0xe,
+ 0x2, 0x2, 0x22e, 0x22f, 0x9, 0xf, 0x2, 0x2, 0x22f, 0x92, 0x3, 0x2, 0x2,
+ 0x2, 0x230, 0x231, 0x9, 0x11, 0x2, 0x2, 0x231, 0x232, 0x9, 0x5, 0x2,
+ 0x2, 0x232, 0x233, 0x9, 0xa, 0x2, 0x2, 0x233, 0x234, 0x9, 0x5, 0x2,
+ 0x2, 0x234, 0x235, 0x9, 0xc, 0x2, 0x2, 0x235, 0x236, 0x9, 0x5, 0x2,
+ 0x2, 0x236, 0x94, 0x3, 0x2, 0x2, 0x2, 0x237, 0x238, 0x9, 0x13, 0x2,
+ 0x2, 0x238, 0x239, 0x9, 0x5, 0x2, 0x2, 0x239, 0x23a, 0x9, 0xd, 0x2,
+ 0x2, 0x23a, 0x23b, 0x9, 0x8, 0x2, 0x2, 0x23b, 0x23c, 0x9, 0x15, 0x2,
+ 0x2, 0x23c, 0x23d, 0x9, 0x5, 0x2, 0x2, 0x23d, 0x96, 0x3, 0x2, 0x2, 0x2,
+ 0x23e, 0x23f, 0x9, 0x10, 0x2, 0x2, 0x23f, 0x240, 0x9, 0x7, 0x2, 0x2,
+ 0x240, 0x241, 0x9, 0xc, 0x2, 0x2, 0x241, 0x242, 0x9, 0xf, 0x2, 0x2,
+ 0x242, 0x98, 0x3, 0x2, 0x2, 0x2, 0x243, 0x244, 0x9, 0x11, 0x2, 0x2,
+ 0x244, 0x245, 0x9, 0x7, 0x2, 0x2, 0x245, 0x246, 0x9, 0x12, 0x2, 0x2,
+ 0x246, 0x247, 0x9, 0xc, 0x2, 0x2, 0x247, 0x248, 0x9, 0x7, 0x2, 0x2,
+ 0x248, 0x249, 0x9, 0x6, 0x2, 0x2, 0x249, 0x24a, 0x9, 0xe, 0x2, 0x2,
+ 0x24a, 0x24b, 0x9, 0xc, 0x2, 0x2, 0x24b, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x24c,
+ 0x24d, 0x9, 0x13, 0x2, 0x2, 0x24d, 0x24e, 0x9, 0x5, 0x2, 0x2, 0x24e,
+ 0x24f, 0x9, 0xc, 0x2, 0x2, 0x24f, 0x250, 0x9, 0x3, 0x2, 0x2, 0x250,
+ 0x251, 0x9, 0x13, 0x2, 0x2, 0x251, 0x252, 0x9, 0x6, 0x2, 0x2, 0x252,
+ 0x9c, 0x3, 0x2, 0x2, 0x2, 0x253, 0x254, 0x9, 0x8, 0x2, 0x2, 0x254, 0x255,
+ 0x9, 0x13, 0x2, 0x2, 0x255, 0x256, 0x9, 0x11, 0x2, 0x2, 0x256, 0x257,
+ 0x9, 0x5, 0x2, 0x2, 0x257, 0x258, 0x9, 0x13, 0x2, 0x2, 0x258, 0x9e,
+ 0x3, 0x2, 0x2, 0x2, 0x259, 0x25a, 0x9, 0x16, 0x2, 0x2, 0x25a, 0x25b,
+ 0x9, 0x17, 0x2, 0x2, 0x25b, 0xa0, 0x3, 0x2, 0x2, 0x2, 0x25c, 0x25d,
+ 0x9, 0x12, 0x2, 0x2, 0x25d, 0x25e, 0x9, 0x18, 0x2, 0x2, 0x25e, 0x25f,
+ 0x9, 0x7, 0x2, 0x2, 0x25f, 0x260, 0x9, 0xb, 0x2, 0x2, 0x260, 0xa2, 0x3,
+ 0x2, 0x2, 0x2, 0x261, 0x262, 0x9, 0xa, 0x2, 0x2, 0x262, 0x263, 0x9,
+ 0x7, 0x2, 0x2, 0x263, 0x264, 0x9, 0xd, 0x2, 0x2, 0x264, 0x265, 0x9,
+ 0x7, 0x2, 0x2, 0x265, 0x266, 0x9, 0xc, 0x2, 0x2, 0x266, 0xa4, 0x3, 0x2,
+ 0x2, 0x2, 0x267, 0x268, 0x9, 0x9, 0x2, 0x2, 0x268, 0x269, 0x9, 0x12,
+ 0x2, 0x2, 0x269, 0x26a, 0x9, 0xe, 0x2, 0x2, 0x26a, 0x26b, 0x9, 0x5,
+ 0x2, 0x2, 0x26b, 0x26c, 0x9, 0x6, 0x2, 0x2, 0x26c, 0x26d, 0x9, 0x11,
+ 0x2, 0x2, 0x26d, 0x26e, 0x9, 0x7, 0x2, 0x2, 0x26e, 0x26f, 0x9, 0x6,
+ 0x2, 0x2, 0x26f, 0x270, 0x9, 0x14, 0x2, 0x2, 0x270, 0xa6, 0x3, 0x2,
+ 0x2, 0x2, 0x271, 0x272, 0x9, 0x9, 0x2, 0x2, 0x272, 0x273, 0x9, 0x12,
+ 0x2, 0x2, 0x273, 0x274, 0x9, 0xe, 0x2, 0x2, 0x274, 0xa8, 0x3, 0x2, 0x2,
+ 0x2, 0x275, 0x276, 0x9, 0x11, 0x2, 0x2, 0x276, 0x277, 0x9, 0x5, 0x2,
+ 0x2, 0x277, 0x278, 0x9, 0x12, 0x2, 0x2, 0x278, 0x279, 0x9, 0xe, 0x2,
+ 0x2, 0x279, 0x27a, 0x9, 0x5, 0x2, 0x2, 0x27a, 0x27b, 0x9, 0x6, 0x2,
+ 0x2, 0x27b, 0x27c, 0x9, 0x11, 0x2, 0x2, 0x27c, 0x27d, 0x9, 0x7, 0x2,
+ 0x2, 0x27d, 0x27e, 0x9, 0x6, 0x2, 0x2, 0x27e, 0x27f, 0x9, 0x14, 0x2,
+ 0x2, 0x27f, 0xaa, 0x3, 0x2, 0x2, 0x2, 0x280, 0x281, 0x9, 0x11, 0x2,
+ 0x2, 0x281, 0x282, 0x9, 0x5, 0x2, 0x2, 0x282, 0x283, 0x9, 0x12, 0x2,
+ 0x2, 0x283, 0x284, 0x9, 0xe, 0x2, 0x2, 0x284, 0xac, 0x3, 0x2, 0x2, 0x2,
+ 0x285, 0x286, 0x9, 0x10, 0x2, 0x2, 0x286, 0x287, 0x9, 0xf, 0x2, 0x2,
+ 0x287, 0x288, 0x9, 0x5, 0x2, 0x2, 0x288, 0x289, 0x9, 0x13, 0x2, 0x2,
+ 0x289, 0x28a, 0x9, 0x5, 0x2, 0x2, 0x28a, 0xae, 0x3, 0x2, 0x2, 0x2, 0x28b,
+ 0x28c, 0x9, 0x8, 0x2, 0x2, 0x28c, 0x28d, 0x9, 0x13, 0x2, 0x2, 0x28d,
+ 0xb0, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x28f, 0x9, 0x19, 0x2, 0x2, 0x28f,
+ 0x290, 0x9, 0x8, 0x2, 0x2, 0x290, 0x291, 0x9, 0x13, 0x2, 0x2, 0x291,
+ 0xb2, 0x3, 0x2, 0x2, 0x2, 0x292, 0x293, 0x9, 0x9, 0x2, 0x2, 0x293, 0x294,
+ 0x9, 0x6, 0x2, 0x2, 0x294, 0x295, 0x9, 0x11, 0x2, 0x2, 0x295, 0xb4,
+ 0x3, 0x2, 0x2, 0x2, 0x296, 0x297, 0x9, 0x6, 0x2, 0x2, 0x297, 0x298,
+ 0x9, 0x8, 0x2, 0x2, 0x298, 0x299, 0x9, 0xc, 0x2, 0x2, 0x299, 0xb6, 0x3,
+ 0x2, 0x2, 0x2, 0x29a, 0x29b, 0x9, 0x7, 0x2, 0x2, 0x29b, 0x29c, 0x9,
+ 0x6, 0x2, 0x2, 0x29c, 0xb8, 0x3, 0x2, 0x2, 0x2, 0x29d, 0x29e, 0x9, 0x12,
+ 0x2, 0x2, 0x29e, 0x29f, 0x9, 0xc, 0x2, 0x2, 0x29f, 0x2a0, 0x9, 0x9,
+ 0x2, 0x2, 0x2a0, 0x2a1, 0x9, 0x13, 0x2, 0x2, 0x2a1, 0x2a2, 0x9, 0xc,
+ 0x2, 0x2, 0x2a2, 0x2a3, 0x9, 0x12, 0x2, 0x2, 0x2a3, 0xba, 0x3, 0x2,
+ 0x2, 0x2, 0x2a4, 0x2a5, 0x9, 0x5, 0x2, 0x2, 0x2a5, 0x2a6, 0x9, 0x6,
+ 0x2, 0x2, 0x2a6, 0x2a7, 0x9, 0x11, 0x2, 0x2, 0x2a7, 0x2a8, 0x9, 0x12,
+ 0x2, 0x2, 0x2a8, 0xbc, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2aa, 0x9, 0xe, 0x2,
+ 0x2, 0x2aa, 0x2ab, 0x9, 0x8, 0x2, 0x2, 0x2ab, 0x2ac, 0x9, 0x6, 0x2,
+ 0x2, 0x2ac, 0x2ad, 0x9, 0xc, 0x2, 0x2, 0x2ad, 0x2ae, 0x9, 0x9, 0x2,
+ 0x2, 0x2ae, 0x2af, 0x9, 0x7, 0x2, 0x2, 0x2af, 0x2b0, 0x9, 0x6, 0x2,
+ 0x2, 0x2b0, 0x2b1, 0x9, 0x12, 0x2, 0x2, 0x2b1, 0xbe, 0x3, 0x2, 0x2,
+ 0x2, 0x2b2, 0x2b3, 0x9, 0x7, 0x2, 0x2, 0x2b3, 0x2b4, 0x9, 0x12, 0x2,
+ 0x2, 0x2b4, 0xc0, 0x3, 0x2, 0x2, 0x2, 0x2b5, 0x2b6, 0x9, 0x6, 0x2, 0x2,
+ 0x2b6, 0x2b7, 0x9, 0x3, 0x2, 0x2, 0x2b7, 0x2b8, 0x9, 0xa, 0x2, 0x2,
+ 0x2b8, 0x2b9, 0x9, 0xa, 0x2, 0x2, 0x2b9, 0xc2, 0x3, 0x2, 0x2, 0x2, 0x2ba,
+ 0x2bb, 0x9, 0xe, 0x2, 0x2, 0x2bb, 0x2bc, 0x9, 0x8, 0x2, 0x2, 0x2bc,
+ 0x2bd, 0x9, 0x3, 0x2, 0x2, 0x2bd, 0x2be, 0x9, 0x6, 0x2, 0x2, 0x2be,
+ 0x2bf, 0x9, 0xc, 0x2, 0x2, 0x2bf, 0xc4, 0x3, 0x2, 0x2, 0x2, 0x2c0, 0x2c1,
+ 0x9, 0x1a, 0x2, 0x2, 0x2c1, 0x2c2, 0x9, 0x7, 0x2, 0x2, 0x2c2, 0x2c3,
+ 0x9, 0xa, 0x2, 0x2, 0x2c3, 0x2c4, 0x9, 0xc, 0x2, 0x2, 0x2c4, 0x2c5,
+ 0x9, 0x5, 0x2, 0x2, 0x2c5, 0x2c6, 0x9, 0x13, 0x2, 0x2, 0x2c6, 0xc6,
+ 0x3, 0x2, 0x2, 0x2, 0x2c7, 0x2c8, 0x9, 0x5, 0x2, 0x2, 0x2c8, 0x2c9,
+ 0x9, 0x19, 0x2, 0x2, 0x2c9, 0x2ca, 0x9, 0xc, 0x2, 0x2, 0x2ca, 0x2cb,
+ 0x9, 0x13, 0x2, 0x2, 0x2cb, 0x2cc, 0x9, 0x9, 0x2, 0x2, 0x2cc, 0x2cd,
+ 0x9, 0xe, 0x2, 0x2, 0x2cd, 0x2ce, 0x9, 0xc, 0x2, 0x2, 0x2ce, 0xc8, 0x3,
+ 0x2, 0x2, 0x2, 0x2cf, 0x2d0, 0x9, 0x9, 0x2, 0x2, 0x2d0, 0x2d1, 0x9,
+ 0x6, 0x2, 0x2, 0x2d1, 0x2d2, 0x9, 0x17, 0x2, 0x2, 0x2d2, 0xca, 0x3,
+ 0x2, 0x2, 0x2, 0x2d3, 0x2d4, 0x9, 0x6, 0x2, 0x2, 0x2d4, 0x2d5, 0x9,
+ 0x8, 0x2, 0x2, 0x2d5, 0x2d6, 0x9, 0x6, 0x2, 0x2, 0x2d6, 0x2d7, 0x9,
+ 0x5, 0x2, 0x2, 0x2d7, 0xcc, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2d9, 0x9, 0x12,
+ 0x2, 0x2, 0x2d9, 0x2da, 0x9, 0x7, 0x2, 0x2, 0x2da, 0x2db, 0x9, 0x6,
+ 0x2, 0x2, 0x2db, 0x2dc, 0x9, 0x14, 0x2, 0x2, 0x2dc, 0x2dd, 0x9, 0xa,
+ 0x2, 0x2, 0x2dd, 0x2de, 0x9, 0x5, 0x2, 0x2, 0x2de, 0xce, 0x3, 0x2, 0x2,
+ 0x2, 0x2df, 0x2e0, 0x9, 0xc, 0x2, 0x2, 0x2e0, 0x2e1, 0x9, 0x13, 0x2,
+ 0x2, 0x2e1, 0x2e2, 0x9, 0x3, 0x2, 0x2, 0x2e2, 0x2e3, 0x9, 0x5, 0x2,
+ 0x2, 0x2e3, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e5, 0x9, 0x1a, 0x2,
+ 0x2, 0x2e5, 0x2e6, 0x9, 0x9, 0x2, 0x2, 0x2e6, 0x2e7, 0x9, 0xa, 0x2,
+ 0x2, 0x2e7, 0x2e8, 0x9, 0x12, 0x2, 0x2, 0x2e8, 0x2e9, 0x9, 0x5, 0x2,
+ 0x2, 0x2e9, 0xd2, 0x3, 0x2, 0x2, 0x2, 0x2ea, 0x2ee, 0x5, 0xd5, 0x6b,
+ 0x2, 0x2eb, 0x2ed, 0x5, 0xd7, 0x6c, 0x2, 0x2ec, 0x2eb, 0x3, 0x2, 0x2,
+ 0x2, 0x2ed, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2ee, 0x2ec, 0x3, 0x2, 0x2,
+ 0x2, 0x2ee, 0x2ef, 0x3, 0x2, 0x2, 0x2, 0x2ef, 0xd4, 0x3, 0x2, 0x2, 0x2,
+ 0x2f0, 0x2ee, 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x2f4, 0x5, 0x105, 0x83, 0x2,
+ 0x2f2, 0x2f4, 0x9, 0x1b, 0x2, 0x2, 0x2f3, 0x2f1, 0x3, 0x2, 0x2, 0x2,
+ 0x2f3, 0x2f2, 0x3, 0x2, 0x2, 0x2, 0x2f4, 0xd6, 0x3, 0x2, 0x2, 0x2, 0x2f5,
+ 0x2f8, 0x5, 0xe7, 0x74, 0x2, 0x2f6, 0x2f8, 0x5, 0xf7, 0x7c, 0x2, 0x2f7,
+ 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x2f7, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x2f8,
+ 0xd8, 0x3, 0x2, 0x2, 0x2, 0x2f9, 0x2fd, 0x7, 0x62, 0x2, 0x2, 0x2fa,
+ 0x2fc, 0x5, 0xe3, 0x72, 0x2, 0x2fb, 0x2fa, 0x3, 0x2, 0x2, 0x2, 0x2fc,
+ 0x2ff, 0x3, 0x2, 0x2, 0x2, 0x2fd, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x2fd,
+ 0x2fe, 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x300, 0x3, 0x2, 0x2, 0x2, 0x2ff,
+ 0x2fd, 0x3, 0x2, 0x2, 0x2, 0x300, 0x302, 0x7, 0x62, 0x2, 0x2, 0x301,
+ 0x2f9, 0x3, 0x2, 0x2, 0x2, 0x302, 0x303, 0x3, 0x2, 0x2, 0x2, 0x303,
+ 0x301, 0x3, 0x2, 0x2, 0x2, 0x303, 0x304, 0x3, 0x2, 0x2, 0x2, 0x304,
+ 0xda, 0x3, 0x2, 0x2, 0x2, 0x305, 0x307, 0x5, 0xdd, 0x6f, 0x2, 0x306,
+ 0x305, 0x3, 0x2, 0x2, 0x2, 0x307, 0x308, 0x3, 0x2, 0x2, 0x2, 0x308,
+ 0x306, 0x3, 0x2, 0x2, 0x2, 0x308, 0x309, 0x3, 0x2, 0x2, 0x2, 0x309,
+ 0xdc, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x317, 0x5, 0xf9, 0x7d, 0x2, 0x30b,
+ 0x317, 0x5, 0xfb, 0x7e, 0x2, 0x30c, 0x317, 0x5, 0xff, 0x80, 0x2, 0x30d,
+ 0x317, 0x5, 0x101, 0x81, 0x2, 0x30e, 0x317, 0x5, 0xe1, 0x71, 0x2, 0x30f,
+ 0x317, 0x5, 0xf5, 0x7b, 0x2, 0x310, 0x317, 0x5, 0xf3, 0x7a, 0x2, 0x311,
+ 0x317, 0x5, 0xf1, 0x79, 0x2, 0x312, 0x317, 0x5, 0xe5, 0x73, 0x2, 0x313,
+ 0x317, 0x5, 0x103, 0x82, 0x2, 0x314, 0x317, 0x9, 0x1c, 0x2, 0x2, 0x315,
+ 0x317, 0x5, 0xdf, 0x70, 0x2, 0x316, 0x30a, 0x3, 0x2, 0x2, 0x2, 0x316,
+ 0x30b, 0x3, 0x2, 0x2, 0x2, 0x316, 0x30c, 0x3, 0x2, 0x2, 0x2, 0x316,
+ 0x30d, 0x3, 0x2, 0x2, 0x2, 0x316, 0x30e, 0x3, 0x2, 0x2, 0x2, 0x316,
+ 0x30f, 0x3, 0x2, 0x2, 0x2, 0x316, 0x310, 0x3, 0x2, 0x2, 0x2, 0x316,
+ 0x311, 0x3, 0x2, 0x2, 0x2, 0x316, 0x312, 0x3, 0x2, 0x2, 0x2, 0x316,
+ 0x313, 0x3, 0x2, 0x2, 0x2, 0x316, 0x314, 0x3, 0x2, 0x2, 0x2, 0x316,
+ 0x315, 0x3, 0x2, 0x2, 0x2, 0x317, 0xde, 0x3, 0x2, 0x2, 0x2, 0x318, 0x319,
+ 0x7, 0x31, 0x2, 0x2, 0x319, 0x31a, 0x7, 0x2c, 0x2, 0x2, 0x31a, 0x320,
+ 0x3, 0x2, 0x2, 0x2, 0x31b, 0x31f, 0x5, 0xe9, 0x75, 0x2, 0x31c, 0x31d,
+ 0x7, 0x2c, 0x2, 0x2, 0x31d, 0x31f, 0x5, 0xef, 0x78, 0x2, 0x31e, 0x31b,
+ 0x3, 0x2, 0x2, 0x2, 0x31e, 0x31c, 0x3, 0x2, 0x2, 0x2, 0x31f, 0x322,
+ 0x3, 0x2, 0x2, 0x2, 0x320, 0x31e, 0x3, 0x2, 0x2, 0x2, 0x320, 0x321,
+ 0x3, 0x2, 0x2, 0x2, 0x321, 0x323, 0x3, 0x2, 0x2, 0x2, 0x322, 0x320,
+ 0x3, 0x2, 0x2, 0x2, 0x323, 0x324, 0x7, 0x2c, 0x2, 0x2, 0x324, 0x336,
+ 0x7, 0x31, 0x2, 0x2, 0x325, 0x326, 0x7, 0x31, 0x2, 0x2, 0x326, 0x327,
+ 0x7, 0x31, 0x2, 0x2, 0x327, 0x32b, 0x3, 0x2, 0x2, 0x2, 0x328, 0x32a,
+ 0x5, 0xed, 0x77, 0x2, 0x329, 0x328, 0x3, 0x2, 0x2, 0x2, 0x32a, 0x32d,
+ 0x3, 0x2, 0x2, 0x2, 0x32b, 0x329, 0x3, 0x2, 0x2, 0x2, 0x32b, 0x32c,
+ 0x3, 0x2, 0x2, 0x2, 0x32c, 0x32f, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x32b,
+ 0x3, 0x2, 0x2, 0x2, 0x32e, 0x330, 0x5, 0xf5, 0x7b, 0x2, 0x32f, 0x32e,
+ 0x3, 0x2, 0x2, 0x2, 0x32f, 0x330, 0x3, 0x2, 0x2, 0x2, 0x330, 0x333,
+ 0x3, 0x2, 0x2, 0x2, 0x331, 0x334, 0x5, 0xff, 0x80, 0x2, 0x332, 0x334,
+ 0x7, 0x2, 0x2, 0x3, 0x333, 0x331, 0x3, 0x2, 0x2, 0x2, 0x333, 0x332,
+ 0x3, 0x2, 0x2, 0x2, 0x334, 0x336, 0x3, 0x2, 0x2, 0x2, 0x335, 0x318,
+ 0x3, 0x2, 0x2, 0x2, 0x335, 0x325, 0x3, 0x2, 0x2, 0x2, 0x336, 0xe0, 0x3,
+ 0x2, 0x2, 0x2, 0x337, 0x338, 0x9, 0x1d, 0x2, 0x2, 0x338, 0xe2, 0x3,
+ 0x2, 0x2, 0x2, 0x339, 0x33a, 0x9, 0x1e, 0x2, 0x2, 0x33a, 0xe4, 0x3,
+ 0x2, 0x2, 0x2, 0x33b, 0x33c, 0x9, 0x1f, 0x2, 0x2, 0x33c, 0xe6, 0x3,
+ 0x2, 0x2, 0x2, 0x33d, 0x33e, 0x9, 0x20, 0x2, 0x2, 0x33e, 0xe8, 0x3,
+ 0x2, 0x2, 0x2, 0x33f, 0x340, 0x9, 0x21, 0x2, 0x2, 0x340, 0xea, 0x3,
+ 0x2, 0x2, 0x2, 0x341, 0x342, 0x9, 0x22, 0x2, 0x2, 0x342, 0xec, 0x3,
+ 0x2, 0x2, 0x2, 0x343, 0x344, 0x9, 0x23, 0x2, 0x2, 0x344, 0xee, 0x3,
+ 0x2, 0x2, 0x2, 0x345, 0x346, 0x9, 0x24, 0x2, 0x2, 0x346, 0xf0, 0x3,
+ 0x2, 0x2, 0x2, 0x347, 0x348, 0x9, 0x25, 0x2, 0x2, 0x348, 0xf2, 0x3,
+ 0x2, 0x2, 0x2, 0x349, 0x34a, 0x9, 0x26, 0x2, 0x2, 0x34a, 0xf4, 0x3,
+ 0x2, 0x2, 0x2, 0x34b, 0x34c, 0x9, 0x27, 0x2, 0x2, 0x34c, 0xf6, 0x3,
+ 0x2, 0x2, 0x2, 0x34d, 0x34e, 0x9, 0x28, 0x2, 0x2, 0x34e, 0xf8, 0x3,
+ 0x2, 0x2, 0x2, 0x34f, 0x350, 0x9, 0x29, 0x2, 0x2, 0x350, 0xfa, 0x3,
+ 0x2, 0x2, 0x2, 0x351, 0x352, 0x9, 0x2a, 0x2, 0x2, 0x352, 0xfc, 0x3,
+ 0x2, 0x2, 0x2, 0x353, 0x354, 0x9, 0x2b, 0x2, 0x2, 0x354, 0xfe, 0x3,
+ 0x2, 0x2, 0x2, 0x355, 0x356, 0x9, 0x2c, 0x2, 0x2, 0x356, 0x100, 0x3,
+ 0x2, 0x2, 0x2, 0x357, 0x358, 0x9, 0x2d, 0x2, 0x2, 0x358, 0x102, 0x3,
+ 0x2, 0x2, 0x2, 0x359, 0x35a, 0x9, 0x2e, 0x2, 0x2, 0x35a, 0x104, 0x3,
+ 0x2, 0x2, 0x2, 0x35b, 0x35c, 0x9, 0x2f, 0x2, 0x2, 0x35c, 0x106, 0x3,
+ 0x2, 0x2, 0x2, 0x29, 0x2, 0x16f, 0x171, 0x178, 0x17a, 0x17e, 0x192,
+ 0x19a, 0x1a1, 0x1a4, 0x1aa, 0x1ad, 0x1b1, 0x1b5, 0x1b9, 0x1bf, 0x1c6,
+ 0x1cb, 0x1d1, 0x1d7, 0x1d9, 0x1dc, 0x1df, 0x1e4, 0x1e9, 0x1f0, 0x2ee,
+ 0x2f3, 0x2f7, 0x2fd, 0x303, 0x308, 0x316, 0x31e, 0x320, 0x32b, 0x32f,
+ 0x333, 0x335, 0x2,
};
atn::ATNDeserializer deserializer;
@@ -1378,7 +921,7 @@ CypherLexer::Initializer::Initializer() {
size_t count = _atn.getNumberOfDecisions();
_decisionToDFA.reserve(count);
- for (size_t i = 0; i < count; i++) {
+ for (size_t i = 0; i < count; i++) {
_decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
}
}
diff --git a/src/query/frontend/opencypher/generated/CypherLexer.h b/src/query/frontend/opencypher/generated/CypherLexer.h
index a6faa4381..d1dcb0516 100644
--- a/src/query/frontend/opencypher/generated/CypherLexer.h
+++ b/src/query/frontend/opencypher/generated/CypherLexer.h
@@ -1,5 +1,5 @@
-// Generated from /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
#pragma once
@@ -20,20 +20,19 @@ public:
T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32,
T__32 = 33, T__33 = 34, T__34 = 35, T__35 = 36, T__36 = 37, T__37 = 38,
T__38 = 39, T__39 = 40, T__40 = 41, T__41 = 42, T__42 = 43, T__43 = 44,
- T__44 = 45, T__45 = 46, T__46 = 47, T__47 = 48, T__48 = 49, StringLiteral = 50,
- EscapedChar = 51, HexInteger = 52, DecimalInteger = 53, OctalInteger = 54,
- HexLetter = 55, HexDigit = 56, Digit = 57, NonZeroDigit = 58, NonZeroOctDigit = 59,
- OctDigit = 60, ZeroDigit = 61, ExponentDecimalReal = 62, RegularDecimalReal = 63,
- UNION = 64, ALL = 65, OPTIONAL = 66, MATCH = 67, UNWIND = 68, AS = 69,
- MERGE = 70, ON = 71, CREATE = 72, SET = 73, DETACH = 74, DELETE = 75,
- REMOVE = 76, WITH = 77, DISTINCT = 78, RETURN = 79, ORDER = 80, BY = 81,
- L_SKIP = 82, LIMIT = 83, ASCENDING = 84, ASC = 85, DESCENDING = 86,
- DESC = 87, WHERE = 88, OR = 89, XOR = 90, AND = 91, NOT = 92, IN = 93,
- STARTS = 94, ENDS = 95, CONTAINS = 96, IS = 97, CYPHERNULL = 98, COUNT = 99,
- FILTER = 100, EXTRACT = 101, ANY = 102, NONE = 103, SINGLE = 104, TRUE = 105,
- FALSE = 106, UnescapedSymbolicName = 107, IdentifierStart = 108, IdentifierPart = 109,
- EscapedSymbolicName = 110, SP = 111, WHITESPACE = 112, Comment = 113,
- L_0X = 114
+ T__44 = 45, T__45 = 46, T__46 = 47, StringLiteral = 48, EscapedChar = 49,
+ HexInteger = 50, DecimalInteger = 51, OctalInteger = 52, HexLetter = 53,
+ HexDigit = 54, Digit = 55, NonZeroDigit = 56, NonZeroOctDigit = 57,
+ OctDigit = 58, ZeroDigit = 59, ExponentDecimalReal = 60, RegularDecimalReal = 61,
+ UNION = 62, ALL = 63, OPTIONAL = 64, MATCH = 65, UNWIND = 66, AS = 67,
+ MERGE = 68, ON = 69, CREATE = 70, SET = 71, DETACH = 72, DELETE = 73,
+ REMOVE = 74, WITH = 75, DISTINCT = 76, RETURN = 77, ORDER = 78, BY = 79,
+ L_SKIP = 80, LIMIT = 81, ASCENDING = 82, ASC = 83, DESCENDING = 84,
+ DESC = 85, WHERE = 86, OR = 87, XOR = 88, AND = 89, NOT = 90, IN = 91,
+ STARTS = 92, ENDS = 93, CONTAINS = 94, IS = 95, CYPHERNULL = 96, COUNT = 97,
+ FILTER = 98, EXTRACT = 99, ANY = 100, NONE = 101, SINGLE = 102, TRUE = 103,
+ FALSE = 104, UnescapedSymbolicName = 105, IdentifierStart = 106, IdentifierPart = 107,
+ EscapedSymbolicName = 108, SP = 109, WHITESPACE = 110, Comment = 111
};
CypherLexer(antlr4::CharStream *input);
diff --git a/src/query/frontend/opencypher/generated/CypherLexer.tokens b/src/query/frontend/opencypher/generated/CypherLexer.tokens
index befaa26c3..cac3f8383 100644
--- a/src/query/frontend/opencypher/generated/CypherLexer.tokens
+++ b/src/query/frontend/opencypher/generated/CypherLexer.tokens
@@ -45,73 +45,70 @@ T__43=44
T__44=45
T__45=46
T__46=47
-T__47=48
-T__48=49
-StringLiteral=50
-EscapedChar=51
-HexInteger=52
-DecimalInteger=53
-OctalInteger=54
-HexLetter=55
-HexDigit=56
-Digit=57
-NonZeroDigit=58
-NonZeroOctDigit=59
-OctDigit=60
-ZeroDigit=61
-ExponentDecimalReal=62
-RegularDecimalReal=63
-UNION=64
-ALL=65
-OPTIONAL=66
-MATCH=67
-UNWIND=68
-AS=69
-MERGE=70
-ON=71
-CREATE=72
-SET=73
-DETACH=74
-DELETE=75
-REMOVE=76
-WITH=77
-DISTINCT=78
-RETURN=79
-ORDER=80
-BY=81
-L_SKIP=82
-LIMIT=83
-ASCENDING=84
-ASC=85
-DESCENDING=86
-DESC=87
-WHERE=88
-OR=89
-XOR=90
-AND=91
-NOT=92
-IN=93
-STARTS=94
-ENDS=95
-CONTAINS=96
-IS=97
-CYPHERNULL=98
-COUNT=99
-FILTER=100
-EXTRACT=101
-ANY=102
-NONE=103
-SINGLE=104
-TRUE=105
-FALSE=106
-UnescapedSymbolicName=107
-IdentifierStart=108
-IdentifierPart=109
-EscapedSymbolicName=110
-SP=111
-WHITESPACE=112
-Comment=113
-L_0X=114
+StringLiteral=48
+EscapedChar=49
+HexInteger=50
+DecimalInteger=51
+OctalInteger=52
+HexLetter=53
+HexDigit=54
+Digit=55
+NonZeroDigit=56
+NonZeroOctDigit=57
+OctDigit=58
+ZeroDigit=59
+ExponentDecimalReal=60
+RegularDecimalReal=61
+UNION=62
+ALL=63
+OPTIONAL=64
+MATCH=65
+UNWIND=66
+AS=67
+MERGE=68
+ON=69
+CREATE=70
+SET=71
+DETACH=72
+DELETE=73
+REMOVE=74
+WITH=75
+DISTINCT=76
+RETURN=77
+ORDER=78
+BY=79
+L_SKIP=80
+LIMIT=81
+ASCENDING=82
+ASC=83
+DESCENDING=84
+DESC=85
+WHERE=86
+OR=87
+XOR=88
+AND=89
+NOT=90
+IN=91
+STARTS=92
+ENDS=93
+CONTAINS=94
+IS=95
+CYPHERNULL=96
+COUNT=97
+FILTER=98
+EXTRACT=99
+ANY=100
+NONE=101
+SINGLE=102
+TRUE=103
+FALSE=104
+UnescapedSymbolicName=105
+IdentifierStart=106
+IdentifierPart=107
+EscapedSymbolicName=108
+SP=109
+WHITESPACE=110
+Comment=111
';'=1
','=2
'='=3
@@ -120,45 +117,43 @@ L_0X=114
'('=6
')'=7
'['=8
-'?'=9
-']'=10
-':'=11
-'|'=12
-'..'=13
-'+'=14
-'-'=15
-'/'=16
-'%'=17
-'^'=18
-'=~'=19
-'<>'=20
-'!='=21
-'<'=22
-'>'=23
-'<='=24
-'>='=25
-'.'=26
-'!'=27
-'{'=28
-'}'=29
-'$'=30
-'⟨'=31
-'〈'=32
-'﹤'=33
-'＜'=34
-'⟩'=35
-'〉'=36
-'﹥'=37
-'＞'=38
-''=39
-'‐'=40
-'‑'=41
-'‒'=42
-'–'=43
-'—'=44
-'―'=45
-'−'=46
-'﹘'=47
-'﹣'=48
-'－'=49
-'0'=61
+']'=9
+':'=10
+'|'=11
+'..'=12
+'+'=13
+'-'=14
+'/'=15
+'%'=16
+'^'=17
+'=~'=18
+'<>'=19
+'!='=20
+'<'=21
+'>'=22
+'<='=23
+'>='=24
+'.'=25
+'{'=26
+'}'=27
+'$'=28
+'⟨'=29
+'〈'=30
+'﹤'=31
+'＜'=32
+'⟩'=33
+'〉'=34
+'﹥'=35
+'＞'=36
+''=37
+'‐'=38
+'‑'=39
+'‒'=40
+'–'=41
+'—'=42
+'―'=43
+'−'=44
+'﹘'=45
+'﹣'=46
+'－'=47
+'0'=59
diff --git a/src/query/frontend/opencypher/generated/CypherListener.cpp b/src/query/frontend/opencypher/generated/CypherListener.cpp
index 8a9a59f98..67176a5b5 100644
--- a/src/query/frontend/opencypher/generated/CypherListener.cpp
+++ b/src/query/frontend/opencypher/generated/CypherListener.cpp
@@ -1,8 +1,9 @@
-// Generated from
-// /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4
-// by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+
#include "CypherListener.h"
+
using namespace antlropencypher;
+
diff --git a/src/query/frontend/opencypher/generated/CypherListener.h b/src/query/frontend/opencypher/generated/CypherListener.h
index 1c940dc06..4a1128f83 100644
--- a/src/query/frontend/opencypher/generated/CypherListener.h
+++ b/src/query/frontend/opencypher/generated/CypherListener.h
@@ -1,5 +1,5 @@
-// Generated from /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
#pragma once
@@ -214,6 +214,9 @@ public:
virtual void enterListComprehension(CypherParser::ListComprehensionContext *ctx) = 0;
virtual void exitListComprehension(CypherParser::ListComprehensionContext *ctx) = 0;
+ virtual void enterPatternComprehension(CypherParser::PatternComprehensionContext *ctx) = 0;
+ virtual void exitPatternComprehension(CypherParser::PatternComprehensionContext *ctx) = 0;
+
virtual void enterPropertyLookup(CypherParser::PropertyLookupContext *ctx) = 0;
virtual void exitPropertyLookup(CypherParser::PropertyLookupContext *ctx) = 0;
diff --git a/src/query/frontend/opencypher/generated/CypherParser.cpp b/src/query/frontend/opencypher/generated/CypherParser.cpp
index a61aceebb..0063fc0a1 100644
--- a/src/query/frontend/opencypher/generated/CypherParser.cpp
+++ b/src/query/frontend/opencypher/generated/CypherParser.cpp
@@ -1,40 +1,45 @@
-// Generated from
-// /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4
-// by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+
#include "CypherListener.h"
#include "CypherVisitor.h"
#include "CypherParser.h"
+
using namespace antlrcpp;
using namespace antlropencypher;
using namespace antlr4;
CypherParser::CypherParser(TokenStream *input) : Parser(input) {
- _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA,
- _sharedContextCache);
+ _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
}
-CypherParser::~CypherParser() { delete _interpreter; }
+CypherParser::~CypherParser() {
+ delete _interpreter;
+}
-std::string CypherParser::getGrammarFileName() const { return "Cypher.g4"; }
+std::string CypherParser::getGrammarFileName() const {
+ return "Cypher.g4";
+}
-const std::vector<std::string> &CypherParser::getRuleNames() const {
+const std::vector<std::string>& CypherParser::getRuleNames() const {
return _ruleNames;
}
-dfa::Vocabulary &CypherParser::getVocabulary() const { return _vocabulary; }
+dfa::Vocabulary& CypherParser::getVocabulary() const {
+ return _vocabulary;
+}
-//----------------- CypherContext
-//------------------------------------------------------------------
-CypherParser::CypherContext::CypherContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+//----------------- CypherContext ------------------------------------------------------------------
-CypherParser::StatementContext *CypherParser::CypherContext::statement() {
+CypherParser::CypherContext::CypherContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::StatementContext* CypherParser::CypherContext::statement() {
return getRuleContext<CypherParser::StatementContext>(0);
}
@@ -42,80 +47,85 @@ std::vector<tree::TerminalNode *> CypherParser::CypherContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::CypherContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::CypherContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::CypherContext::getRuleIndex() const {
return CypherParser::RuleCypher;
}
void CypherParser::CypherContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterCypher(this);
+ if (parserListener != nullptr)
+ parserListener->enterCypher(this);
}
void CypherParser::CypherContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitCypher(this);
+ if (parserListener != nullptr)
+ parserListener->exitCypher(this);
}
-antlrcpp::Any CypherParser::CypherContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::CypherContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitCypher(this);
else
return visitor->visitChildren(this);
}
-CypherParser::CypherContext *CypherParser::cypher() {
- CypherContext *_localctx =
- _tracker.createInstance<CypherContext>(_ctx, getState());
+CypherParser::CypherContext* CypherParser::cypher() {
+ CypherContext *_localctx = _tracker.createInstance<CypherContext>(_ctx, getState());
enterRule(_localctx, 0, CypherParser::RuleCypher);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(159);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(158);
- match(CypherParser::SP);
- }
setState(161);
- statement();
- setState(166);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 2, _ctx)) {
- case 1: {
- setState(163);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(162);
- match(CypherParser::SP);
- }
- setState(165);
- match(CypherParser::T__0);
- break;
- }
- }
- setState(169);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(168);
+ setState(160);
match(CypherParser::SP);
}
+ setState(163);
+ statement();
+ setState(168);
+ _errHandler->sync(this);
- } catch (RecognitionException &e) {
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx)) {
+ case 1: {
+ setState(165);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(164);
+ match(CypherParser::SP);
+ }
+ setState(167);
+ match(CypherParser::T__0);
+ break;
+ }
+
+ }
+ setState(171);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(170);
+ match(CypherParser::SP);
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -124,53 +134,55 @@ CypherParser::CypherContext *CypherParser::cypher() {
return _localctx;
}
-//----------------- StatementContext
-//------------------------------------------------------------------
+//----------------- StatementContext ------------------------------------------------------------------
-CypherParser::StatementContext::StatementContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::QueryContext *CypherParser::StatementContext::query() {
+CypherParser::QueryContext* CypherParser::StatementContext::query() {
return getRuleContext<CypherParser::QueryContext>(0);
}
+
size_t CypherParser::StatementContext::getRuleIndex() const {
return CypherParser::RuleStatement;
}
-void CypherParser::StatementContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::StatementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterStatement(this);
+ if (parserListener != nullptr)
+ parserListener->enterStatement(this);
}
-void CypherParser::StatementContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::StatementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitStatement(this);
+ if (parserListener != nullptr)
+ parserListener->exitStatement(this);
}
-antlrcpp::Any CypherParser::StatementContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitStatement(this);
else
return visitor->visitChildren(this);
}
-CypherParser::StatementContext *CypherParser::statement() {
- StatementContext *_localctx =
- _tracker.createInstance<StatementContext>(_ctx, getState());
+CypherParser::StatementContext* CypherParser::statement() {
+ StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
enterRule(_localctx, 2, CypherParser::RuleStatement);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(171);
+ setState(173);
query();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -179,51 +191,55 @@ CypherParser::StatementContext *CypherParser::statement() {
return _localctx;
}
-//----------------- QueryContext
-//------------------------------------------------------------------
+//----------------- QueryContext ------------------------------------------------------------------
-CypherParser::QueryContext::QueryContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::QueryContext::QueryContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::RegularQueryContext *CypherParser::QueryContext::regularQuery() {
+CypherParser::RegularQueryContext* CypherParser::QueryContext::regularQuery() {
return getRuleContext<CypherParser::RegularQueryContext>(0);
}
+
size_t CypherParser::QueryContext::getRuleIndex() const {
return CypherParser::RuleQuery;
}
void CypherParser::QueryContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterQuery(this);
+ if (parserListener != nullptr)
+ parserListener->enterQuery(this);
}
void CypherParser::QueryContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitQuery(this);
+ if (parserListener != nullptr)
+ parserListener->exitQuery(this);
}
-antlrcpp::Any CypherParser::QueryContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::QueryContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitQuery(this);
else
return visitor->visitChildren(this);
}
-CypherParser::QueryContext *CypherParser::query() {
- QueryContext *_localctx =
- _tracker.createInstance<QueryContext>(_ctx, getState());
+CypherParser::QueryContext* CypherParser::query() {
+ QueryContext *_localctx = _tracker.createInstance<QueryContext>(_ctx, getState());
enterRule(_localctx, 4, CypherParser::RuleQuery);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(173);
+ setState(175);
regularQuery();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -232,25 +248,21 @@ CypherParser::QueryContext *CypherParser::query() {
return _localctx;
}
-//----------------- RegularQueryContext
-//------------------------------------------------------------------
+//----------------- RegularQueryContext ------------------------------------------------------------------
-CypherParser::RegularQueryContext::RegularQueryContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::RegularQueryContext::RegularQueryContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::SingleQueryContext *
-CypherParser::RegularQueryContext::singleQuery() {
+CypherParser::SingleQueryContext* CypherParser::RegularQueryContext::singleQuery() {
return getRuleContext<CypherParser::SingleQueryContext>(0);
}
-std::vector<CypherParser::CypherUnionContext *>
-CypherParser::RegularQueryContext::cypherUnion() {
+std::vector<CypherParser::CypherUnionContext *> CypherParser::RegularQueryContext::cypherUnion() {
return getRuleContexts<CypherParser::CypherUnionContext>();
}
-CypherParser::CypherUnionContext *
-CypherParser::RegularQueryContext::cypherUnion(size_t i) {
+CypherParser::CypherUnionContext* CypherParser::RegularQueryContext::cypherUnion(size_t i) {
return getRuleContext<CypherParser::CypherUnionContext>(i);
}
@@ -258,70 +270,71 @@ std::vector<tree::TerminalNode *> CypherParser::RegularQueryContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::RegularQueryContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::RegularQueryContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::RegularQueryContext::getRuleIndex() const {
return CypherParser::RuleRegularQuery;
}
-void CypherParser::RegularQueryContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RegularQueryContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRegularQuery(this);
+ if (parserListener != nullptr)
+ parserListener->enterRegularQuery(this);
}
-void CypherParser::RegularQueryContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RegularQueryContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRegularQuery(this);
+ if (parserListener != nullptr)
+ parserListener->exitRegularQuery(this);
}
-antlrcpp::Any CypherParser::RegularQueryContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RegularQueryContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRegularQuery(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RegularQueryContext *CypherParser::regularQuery() {
- RegularQueryContext *_localctx =
- _tracker.createInstance<RegularQueryContext>(_ctx, getState());
+CypherParser::RegularQueryContext* CypherParser::regularQuery() {
+ RegularQueryContext *_localctx = _tracker.createInstance<RegularQueryContext>(_ctx, getState());
enterRule(_localctx, 6, CypherParser::RuleRegularQuery);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(175);
+ setState(177);
singleQuery();
- setState(182);
+ setState(184);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5,
- _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(177);
+ setState(179);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(176);
+ setState(178);
match(CypherParser::SP);
}
- setState(179);
- cypherUnion();
+ setState(181);
+ cypherUnion();
}
- setState(184);
+ setState(186);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 5, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -330,20 +343,17 @@ CypherParser::RegularQueryContext *CypherParser::regularQuery() {
return _localctx;
}
-//----------------- SingleQueryContext
-//------------------------------------------------------------------
+//----------------- SingleQueryContext ------------------------------------------------------------------
-CypherParser::SingleQueryContext::SingleQueryContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::SingleQueryContext::SingleQueryContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::ClauseContext *>
-CypherParser::SingleQueryContext::clause() {
+std::vector<CypherParser::ClauseContext *> CypherParser::SingleQueryContext::clause() {
return getRuleContexts<CypherParser::ClauseContext>();
}
-CypherParser::ClauseContext *CypherParser::SingleQueryContext::clause(
- size_t i) {
+CypherParser::ClauseContext* CypherParser::SingleQueryContext::clause(size_t i) {
return getRuleContext<CypherParser::ClauseContext>(i);
}
@@ -351,70 +361,71 @@ std::vector<tree::TerminalNode *> CypherParser::SingleQueryContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::SingleQueryContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::SingleQueryContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::SingleQueryContext::getRuleIndex() const {
return CypherParser::RuleSingleQuery;
}
-void CypherParser::SingleQueryContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::SingleQueryContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterSingleQuery(this);
+ if (parserListener != nullptr)
+ parserListener->enterSingleQuery(this);
}
-void CypherParser::SingleQueryContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::SingleQueryContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitSingleQuery(this);
+ if (parserListener != nullptr)
+ parserListener->exitSingleQuery(this);
}
-antlrcpp::Any CypherParser::SingleQueryContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::SingleQueryContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitSingleQuery(this);
else
return visitor->visitChildren(this);
}
-CypherParser::SingleQueryContext *CypherParser::singleQuery() {
- SingleQueryContext *_localctx =
- _tracker.createInstance<SingleQueryContext>(_ctx, getState());
+CypherParser::SingleQueryContext* CypherParser::singleQuery() {
+ SingleQueryContext *_localctx = _tracker.createInstance<SingleQueryContext>(_ctx, getState());
enterRule(_localctx, 8, CypherParser::RuleSingleQuery);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(185);
+ setState(187);
clause();
- setState(192);
+ setState(194);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7,
- _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(187);
+ setState(189);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(186);
+ setState(188);
match(CypherParser::SP);
}
- setState(189);
- clause();
+ setState(191);
+ clause();
}
- setState(194);
+ setState(196);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 7, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -423,14 +434,13 @@ CypherParser::SingleQueryContext *CypherParser::singleQuery() {
return _localctx;
}
-//----------------- CypherUnionContext
-//------------------------------------------------------------------
+//----------------- CypherUnionContext ------------------------------------------------------------------
-CypherParser::CypherUnionContext::CypherUnionContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::CypherUnionContext::CypherUnionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::CypherUnionContext::UNION() {
+tree::TerminalNode* CypherParser::CypherUnionContext::UNION() {
return getToken(CypherParser::UNION, 0);
}
@@ -438,95 +448,97 @@ std::vector<tree::TerminalNode *> CypherParser::CypherUnionContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::CypherUnionContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::CypherUnionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-tree::TerminalNode *CypherParser::CypherUnionContext::ALL() {
+tree::TerminalNode* CypherParser::CypherUnionContext::ALL() {
return getToken(CypherParser::ALL, 0);
}
-CypherParser::SingleQueryContext *
-CypherParser::CypherUnionContext::singleQuery() {
+CypherParser::SingleQueryContext* CypherParser::CypherUnionContext::singleQuery() {
return getRuleContext<CypherParser::SingleQueryContext>(0);
}
+
size_t CypherParser::CypherUnionContext::getRuleIndex() const {
return CypherParser::RuleCypherUnion;
}
-void CypherParser::CypherUnionContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherUnionContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterCypherUnion(this);
+ if (parserListener != nullptr)
+ parserListener->enterCypherUnion(this);
}
-void CypherParser::CypherUnionContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherUnionContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitCypherUnion(this);
+ if (parserListener != nullptr)
+ parserListener->exitCypherUnion(this);
}
-antlrcpp::Any CypherParser::CypherUnionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::CypherUnionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitCypherUnion(this);
else
return visitor->visitChildren(this);
}
-CypherParser::CypherUnionContext *CypherParser::cypherUnion() {
- CypherUnionContext *_localctx =
- _tracker.createInstance<CypherUnionContext>(_ctx, getState());
+CypherParser::CypherUnionContext* CypherParser::cypherUnion() {
+ CypherUnionContext *_localctx = _tracker.createInstance<CypherUnionContext>(_ctx, getState());
enterRule(_localctx, 10, CypherParser::RuleCypherUnion);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(207);
+ setState(209);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 10, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(195);
- match(CypherParser::UNION);
- setState(196);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(197);
+ match(CypherParser::UNION);
+ setState(198);
+ match(CypherParser::SP);
+ setState(199);
+ match(CypherParser::ALL);
+ setState(201);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(200);
match(CypherParser::SP);
- setState(197);
- match(CypherParser::ALL);
- setState(199);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(198);
- match(CypherParser::SP);
- }
- setState(201);
- singleQuery();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(202);
- match(CypherParser::UNION);
- setState(204);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(203);
- match(CypherParser::SP);
- }
- setState(206);
- singleQuery();
- break;
}
+ setState(203);
+ singleQuery();
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(204);
+ match(CypherParser::UNION);
+ setState(206);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(205);
+ match(CypherParser::SP);
+ }
+ setState(208);
+ singleQuery();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -535,113 +547,116 @@ CypherParser::CypherUnionContext *CypherParser::cypherUnion() {
return _localctx;
}
-//----------------- ClauseContext
-//------------------------------------------------------------------
+//----------------- ClauseContext ------------------------------------------------------------------
-CypherParser::ClauseContext::ClauseContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::ClauseContext::ClauseContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::CypherMatchContext *CypherParser::ClauseContext::cypherMatch() {
+CypherParser::CypherMatchContext* CypherParser::ClauseContext::cypherMatch() {
return getRuleContext<CypherParser::CypherMatchContext>(0);
}
-CypherParser::UnwindContext *CypherParser::ClauseContext::unwind() {
+CypherParser::UnwindContext* CypherParser::ClauseContext::unwind() {
return getRuleContext<CypherParser::UnwindContext>(0);
}
-CypherParser::MergeContext *CypherParser::ClauseContext::merge() {
+CypherParser::MergeContext* CypherParser::ClauseContext::merge() {
return getRuleContext<CypherParser::MergeContext>(0);
}
-CypherParser::CreateContext *CypherParser::ClauseContext::create() {
+CypherParser::CreateContext* CypherParser::ClauseContext::create() {
return getRuleContext<CypherParser::CreateContext>(0);
}
-CypherParser::SetContext *CypherParser::ClauseContext::set() {
+CypherParser::SetContext* CypherParser::ClauseContext::set() {
return getRuleContext<CypherParser::SetContext>(0);
}
-CypherParser::CypherDeleteContext *CypherParser::ClauseContext::cypherDelete() {
+CypherParser::CypherDeleteContext* CypherParser::ClauseContext::cypherDelete() {
return getRuleContext<CypherParser::CypherDeleteContext>(0);
}
-CypherParser::RemoveContext *CypherParser::ClauseContext::remove() {
+CypherParser::RemoveContext* CypherParser::ClauseContext::remove() {
return getRuleContext<CypherParser::RemoveContext>(0);
}
-CypherParser::WithContext *CypherParser::ClauseContext::with() {
+CypherParser::WithContext* CypherParser::ClauseContext::with() {
return getRuleContext<CypherParser::WithContext>(0);
}
-CypherParser::CypherReturnContext *CypherParser::ClauseContext::cypherReturn() {
+CypherParser::CypherReturnContext* CypherParser::ClauseContext::cypherReturn() {
return getRuleContext<CypherParser::CypherReturnContext>(0);
}
+
size_t CypherParser::ClauseContext::getRuleIndex() const {
return CypherParser::RuleClause;
}
void CypherParser::ClauseContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterClause(this);
+ if (parserListener != nullptr)
+ parserListener->enterClause(this);
}
void CypherParser::ClauseContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitClause(this);
+ if (parserListener != nullptr)
+ parserListener->exitClause(this);
}
-antlrcpp::Any CypherParser::ClauseContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::ClauseContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitClause(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ClauseContext *CypherParser::clause() {
- ClauseContext *_localctx =
- _tracker.createInstance<ClauseContext>(_ctx, getState());
+CypherParser::ClauseContext* CypherParser::clause() {
+ ClauseContext *_localctx = _tracker.createInstance<ClauseContext>(_ctx, getState());
enterRule(_localctx, 12, CypherParser::RuleClause);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(218);
+ setState(220);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::OPTIONAL:
case CypherParser::MATCH: {
enterOuterAlt(_localctx, 1);
- setState(209);
+ setState(211);
cypherMatch();
break;
}
case CypherParser::UNWIND: {
enterOuterAlt(_localctx, 2);
- setState(210);
+ setState(212);
unwind();
break;
}
case CypherParser::MERGE: {
enterOuterAlt(_localctx, 3);
- setState(211);
+ setState(213);
merge();
break;
}
case CypherParser::CREATE: {
enterOuterAlt(_localctx, 4);
- setState(212);
+ setState(214);
create();
break;
}
case CypherParser::SET: {
enterOuterAlt(_localctx, 5);
- setState(213);
+ setState(215);
set();
break;
}
@@ -649,37 +664,38 @@ CypherParser::ClauseContext *CypherParser::clause() {
case CypherParser::DETACH:
case CypherParser::DELETE: {
enterOuterAlt(_localctx, 6);
- setState(214);
+ setState(216);
cypherDelete();
break;
}
case CypherParser::REMOVE: {
enterOuterAlt(_localctx, 7);
- setState(215);
+ setState(217);
remove();
break;
}
case CypherParser::WITH: {
enterOuterAlt(_localctx, 8);
- setState(216);
+ setState(218);
with();
break;
}
case CypherParser::RETURN: {
enterOuterAlt(_localctx, 9);
- setState(217);
+ setState(219);
cypherReturn();
break;
}
- default:
- throw NoViableAltException(this);
+ default:
+ throw NoViableAltException(this);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -688,22 +704,21 @@ CypherParser::ClauseContext *CypherParser::clause() {
return _localctx;
}
-//----------------- CypherMatchContext
-//------------------------------------------------------------------
+//----------------- CypherMatchContext ------------------------------------------------------------------
-CypherParser::CypherMatchContext::CypherMatchContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::CypherMatchContext::CypherMatchContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::CypherMatchContext::MATCH() {
+tree::TerminalNode* CypherParser::CypherMatchContext::MATCH() {
return getToken(CypherParser::MATCH, 0);
}
-CypherParser::PatternContext *CypherParser::CypherMatchContext::pattern() {
+CypherParser::PatternContext* CypherParser::CypherMatchContext::pattern() {
return getRuleContext<CypherParser::PatternContext>(0);
}
-tree::TerminalNode *CypherParser::CypherMatchContext::OPTIONAL() {
+tree::TerminalNode* CypherParser::CypherMatchContext::OPTIONAL() {
return getToken(CypherParser::OPTIONAL, 0);
}
@@ -711,90 +726,93 @@ std::vector<tree::TerminalNode *> CypherParser::CypherMatchContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::CypherMatchContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::CypherMatchContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::WhereContext *CypherParser::CypherMatchContext::where() {
+CypherParser::WhereContext* CypherParser::CypherMatchContext::where() {
return getRuleContext<CypherParser::WhereContext>(0);
}
+
size_t CypherParser::CypherMatchContext::getRuleIndex() const {
return CypherParser::RuleCypherMatch;
}
-void CypherParser::CypherMatchContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherMatchContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterCypherMatch(this);
+ if (parserListener != nullptr)
+ parserListener->enterCypherMatch(this);
}
-void CypherParser::CypherMatchContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherMatchContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitCypherMatch(this);
+ if (parserListener != nullptr)
+ parserListener->exitCypherMatch(this);
}
-antlrcpp::Any CypherParser::CypherMatchContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::CypherMatchContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitCypherMatch(this);
else
return visitor->visitChildren(this);
}
-CypherParser::CypherMatchContext *CypherParser::cypherMatch() {
- CypherMatchContext *_localctx =
- _tracker.createInstance<CypherMatchContext>(_ctx, getState());
+CypherParser::CypherMatchContext* CypherParser::cypherMatch() {
+ CypherMatchContext *_localctx = _tracker.createInstance<CypherMatchContext>(_ctx, getState());
enterRule(_localctx, 14, CypherParser::RuleCypherMatch);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(222);
+ setState(224);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::OPTIONAL) {
- setState(220);
+ setState(222);
match(CypherParser::OPTIONAL);
- setState(221);
+ setState(223);
match(CypherParser::SP);
}
- setState(224);
- match(CypherParser::MATCH);
setState(226);
+ match(CypherParser::MATCH);
+ setState(228);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(225);
+ setState(227);
match(CypherParser::SP);
}
- setState(228);
+ setState(230);
pattern();
- setState(233);
+ setState(235);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 15, _ctx)) {
- case 1: {
- setState(230);
- _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {
+ case 1: {
+ setState(232);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(229);
- match(CypherParser::SP);
- }
- setState(232);
- where();
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(231);
+ match(CypherParser::SP);
}
+ setState(234);
+ where();
+ break;
}
- } catch (RecognitionException &e) {
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -803,18 +821,17 @@ CypherParser::CypherMatchContext *CypherParser::cypherMatch() {
return _localctx;
}
-//----------------- UnwindContext
-//------------------------------------------------------------------
+//----------------- UnwindContext ------------------------------------------------------------------
-CypherParser::UnwindContext::UnwindContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::UnwindContext::UnwindContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::UnwindContext::UNWIND() {
+tree::TerminalNode* CypherParser::UnwindContext::UNWIND() {
return getToken(CypherParser::UNWIND, 0);
}
-CypherParser::ExpressionContext *CypherParser::UnwindContext::expression() {
+CypherParser::ExpressionContext* CypherParser::UnwindContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
@@ -822,71 +839,76 @@ std::vector<tree::TerminalNode *> CypherParser::UnwindContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::UnwindContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::UnwindContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-tree::TerminalNode *CypherParser::UnwindContext::AS() {
+tree::TerminalNode* CypherParser::UnwindContext::AS() {
return getToken(CypherParser::AS, 0);
}
-CypherParser::VariableContext *CypherParser::UnwindContext::variable() {
+CypherParser::VariableContext* CypherParser::UnwindContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
+
size_t CypherParser::UnwindContext::getRuleIndex() const {
return CypherParser::RuleUnwind;
}
void CypherParser::UnwindContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterUnwind(this);
+ if (parserListener != nullptr)
+ parserListener->enterUnwind(this);
}
void CypherParser::UnwindContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitUnwind(this);
+ if (parserListener != nullptr)
+ parserListener->exitUnwind(this);
}
-antlrcpp::Any CypherParser::UnwindContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::UnwindContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitUnwind(this);
else
return visitor->visitChildren(this);
}
-CypherParser::UnwindContext *CypherParser::unwind() {
- UnwindContext *_localctx =
- _tracker.createInstance<UnwindContext>(_ctx, getState());
+CypherParser::UnwindContext* CypherParser::unwind() {
+ UnwindContext *_localctx = _tracker.createInstance<UnwindContext>(_ctx, getState());
enterRule(_localctx, 16, CypherParser::RuleUnwind);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(235);
- match(CypherParser::UNWIND);
setState(237);
+ match(CypherParser::UNWIND);
+ setState(239);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(236);
+ setState(238);
match(CypherParser::SP);
}
- setState(239);
- expression();
- setState(240);
- match(CypherParser::SP);
setState(241);
- match(CypherParser::AS);
+ expression();
setState(242);
match(CypherParser::SP);
setState(243);
+ match(CypherParser::AS);
+ setState(244);
+ match(CypherParser::SP);
+ setState(245);
variable();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -895,18 +917,17 @@ CypherParser::UnwindContext *CypherParser::unwind() {
return _localctx;
}
-//----------------- MergeContext
-//------------------------------------------------------------------
+//----------------- MergeContext ------------------------------------------------------------------
-CypherParser::MergeContext::MergeContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::MergeContext::MergeContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::MergeContext::MERGE() {
+tree::TerminalNode* CypherParser::MergeContext::MERGE() {
return getToken(CypherParser::MERGE, 0);
}
-CypherParser::PatternPartContext *CypherParser::MergeContext::patternPart() {
+CypherParser::PatternPartContext* CypherParser::MergeContext::patternPart() {
return getRuleContext<CypherParser::PatternPartContext>(0);
}
@@ -914,82 +935,83 @@ std::vector<tree::TerminalNode *> CypherParser::MergeContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::MergeContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::MergeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-std::vector<CypherParser::MergeActionContext *>
-CypherParser::MergeContext::mergeAction() {
+std::vector<CypherParser::MergeActionContext *> CypherParser::MergeContext::mergeAction() {
return getRuleContexts<CypherParser::MergeActionContext>();
}
-CypherParser::MergeActionContext *CypherParser::MergeContext::mergeAction(
- size_t i) {
+CypherParser::MergeActionContext* CypherParser::MergeContext::mergeAction(size_t i) {
return getRuleContext<CypherParser::MergeActionContext>(i);
}
+
size_t CypherParser::MergeContext::getRuleIndex() const {
return CypherParser::RuleMerge;
}
void CypherParser::MergeContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterMerge(this);
+ if (parserListener != nullptr)
+ parserListener->enterMerge(this);
}
void CypherParser::MergeContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitMerge(this);
+ if (parserListener != nullptr)
+ parserListener->exitMerge(this);
}
-antlrcpp::Any CypherParser::MergeContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::MergeContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitMerge(this);
else
return visitor->visitChildren(this);
}
-CypherParser::MergeContext *CypherParser::merge() {
- MergeContext *_localctx =
- _tracker.createInstance<MergeContext>(_ctx, getState());
+CypherParser::MergeContext* CypherParser::merge() {
+ MergeContext *_localctx = _tracker.createInstance<MergeContext>(_ctx, getState());
enterRule(_localctx, 18, CypherParser::RuleMerge);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(245);
- match(CypherParser::MERGE);
setState(247);
+ match(CypherParser::MERGE);
+ setState(249);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(246);
+ setState(248);
match(CypherParser::SP);
}
- setState(249);
+ setState(251);
patternPart();
- setState(254);
+ setState(256);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18,
- _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(250);
+ setState(252);
match(CypherParser::SP);
- setState(251);
- mergeAction();
+ setState(253);
+ mergeAction();
}
- setState(256);
+ setState(258);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 18, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -998,14 +1020,13 @@ CypherParser::MergeContext *CypherParser::merge() {
return _localctx;
}
-//----------------- MergeActionContext
-//------------------------------------------------------------------
+//----------------- MergeActionContext ------------------------------------------------------------------
-CypherParser::MergeActionContext::MergeActionContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::MergeActionContext::MergeActionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::MergeActionContext::ON() {
+tree::TerminalNode* CypherParser::MergeActionContext::ON() {
return getToken(CypherParser::ON, 0);
}
@@ -1013,89 +1034,92 @@ std::vector<tree::TerminalNode *> CypherParser::MergeActionContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::MergeActionContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::MergeActionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-tree::TerminalNode *CypherParser::MergeActionContext::MATCH() {
+tree::TerminalNode* CypherParser::MergeActionContext::MATCH() {
return getToken(CypherParser::MATCH, 0);
}
-CypherParser::SetContext *CypherParser::MergeActionContext::set() {
+CypherParser::SetContext* CypherParser::MergeActionContext::set() {
return getRuleContext<CypherParser::SetContext>(0);
}
-tree::TerminalNode *CypherParser::MergeActionContext::CREATE() {
+tree::TerminalNode* CypherParser::MergeActionContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
+
size_t CypherParser::MergeActionContext::getRuleIndex() const {
return CypherParser::RuleMergeAction;
}
-void CypherParser::MergeActionContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::MergeActionContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterMergeAction(this);
+ if (parserListener != nullptr)
+ parserListener->enterMergeAction(this);
}
-void CypherParser::MergeActionContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::MergeActionContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitMergeAction(this);
+ if (parserListener != nullptr)
+ parserListener->exitMergeAction(this);
}
-antlrcpp::Any CypherParser::MergeActionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::MergeActionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitMergeAction(this);
else
return visitor->visitChildren(this);
}
-CypherParser::MergeActionContext *CypherParser::mergeAction() {
- MergeActionContext *_localctx =
- _tracker.createInstance<MergeActionContext>(_ctx, getState());
+CypherParser::MergeActionContext* CypherParser::mergeAction() {
+ MergeActionContext *_localctx = _tracker.createInstance<MergeActionContext>(_ctx, getState());
enterRule(_localctx, 20, CypherParser::RuleMergeAction);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(267);
+ setState(269);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 19, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(257);
- match(CypherParser::ON);
- setState(258);
- match(CypherParser::SP);
- setState(259);
- match(CypherParser::MATCH);
- setState(260);
- match(CypherParser::SP);
- setState(261);
- set();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(262);
- match(CypherParser::ON);
- setState(263);
- match(CypherParser::SP);
- setState(264);
- match(CypherParser::CREATE);
- setState(265);
- match(CypherParser::SP);
- setState(266);
- set();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(259);
+ match(CypherParser::ON);
+ setState(260);
+ match(CypherParser::SP);
+ setState(261);
+ match(CypherParser::MATCH);
+ setState(262);
+ match(CypherParser::SP);
+ setState(263);
+ set();
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(264);
+ match(CypherParser::ON);
+ setState(265);
+ match(CypherParser::SP);
+ setState(266);
+ match(CypherParser::CREATE);
+ setState(267);
+ match(CypherParser::SP);
+ setState(268);
+ set();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1104,70 +1128,74 @@ CypherParser::MergeActionContext *CypherParser::mergeAction() {
return _localctx;
}
-//----------------- CreateContext
-//------------------------------------------------------------------
+//----------------- CreateContext ------------------------------------------------------------------
-CypherParser::CreateContext::CreateContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::CreateContext::CreateContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::CreateContext::CREATE() {
+tree::TerminalNode* CypherParser::CreateContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
-CypherParser::PatternContext *CypherParser::CreateContext::pattern() {
+CypherParser::PatternContext* CypherParser::CreateContext::pattern() {
return getRuleContext<CypherParser::PatternContext>(0);
}
-tree::TerminalNode *CypherParser::CreateContext::SP() {
+tree::TerminalNode* CypherParser::CreateContext::SP() {
return getToken(CypherParser::SP, 0);
}
+
size_t CypherParser::CreateContext::getRuleIndex() const {
return CypherParser::RuleCreate;
}
void CypherParser::CreateContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterCreate(this);
+ if (parserListener != nullptr)
+ parserListener->enterCreate(this);
}
void CypherParser::CreateContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitCreate(this);
+ if (parserListener != nullptr)
+ parserListener->exitCreate(this);
}
-antlrcpp::Any CypherParser::CreateContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::CreateContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitCreate(this);
else
return visitor->visitChildren(this);
}
-CypherParser::CreateContext *CypherParser::create() {
- CreateContext *_localctx =
- _tracker.createInstance<CreateContext>(_ctx, getState());
+CypherParser::CreateContext* CypherParser::create() {
+ CreateContext *_localctx = _tracker.createInstance<CreateContext>(_ctx, getState());
enterRule(_localctx, 22, CypherParser::RuleCreate);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(269);
- match(CypherParser::CREATE);
setState(271);
+ match(CypherParser::CREATE);
+ setState(273);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(270);
+ setState(272);
match(CypherParser::SP);
}
- setState(273);
+ setState(275);
pattern();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1176,74 +1204,90 @@ CypherParser::CreateContext *CypherParser::create() {
return _localctx;
}
-//----------------- SetContext
-//------------------------------------------------------------------
+//----------------- SetContext ------------------------------------------------------------------
-CypherParser::SetContext::SetContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::SetContext::SetContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::SetContext::SET() {
+tree::TerminalNode* CypherParser::SetContext::SET() {
return getToken(CypherParser::SET, 0);
}
-std::vector<CypherParser::SetItemContext *>
-CypherParser::SetContext::setItem() {
+std::vector<CypherParser::SetItemContext *> CypherParser::SetContext::setItem() {
return getRuleContexts<CypherParser::SetItemContext>();
}
-CypherParser::SetItemContext *CypherParser::SetContext::setItem(size_t i) {
+CypherParser::SetItemContext* CypherParser::SetContext::setItem(size_t i) {
return getRuleContext<CypherParser::SetItemContext>(i);
}
+tree::TerminalNode* CypherParser::SetContext::SP() {
+ return getToken(CypherParser::SP, 0);
+}
+
+
size_t CypherParser::SetContext::getRuleIndex() const {
return CypherParser::RuleSet;
}
void CypherParser::SetContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterSet(this);
+ if (parserListener != nullptr)
+ parserListener->enterSet(this);
}
void CypherParser::SetContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitSet(this);
+ if (parserListener != nullptr)
+ parserListener->exitSet(this);
}
-antlrcpp::Any CypherParser::SetContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::SetContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitSet(this);
else
return visitor->visitChildren(this);
}
-CypherParser::SetContext *CypherParser::set() {
+CypherParser::SetContext* CypherParser::set() {
SetContext *_localctx = _tracker.createInstance<SetContext>(_ctx, getState());
enterRule(_localctx, 24, CypherParser::RuleSet);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(275);
+ setState(277);
match(CypherParser::SET);
- setState(276);
- setItem();
+ setState(279);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(278);
+ match(CypherParser::SP);
+ }
setState(281);
+ setItem();
+ setState(286);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__1) {
- setState(277);
+ setState(282);
match(CypherParser::T__1);
- setState(278);
- setItem();
setState(283);
+ setItem();
+ setState(288);
_errHandler->sync(this);
_la = _input->LA(1);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1252,108 +1296,175 @@ CypherParser::SetContext *CypherParser::set() {
return _localctx;
}
-//----------------- SetItemContext
-//------------------------------------------------------------------
+//----------------- SetItemContext ------------------------------------------------------------------
-CypherParser::SetItemContext::SetItemContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::SetItemContext::SetItemContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::PropertyExpressionContext *
-CypherParser::SetItemContext::propertyExpression() {
+CypherParser::PropertyExpressionContext* CypherParser::SetItemContext::propertyExpression() {
return getRuleContext<CypherParser::PropertyExpressionContext>(0);
}
-CypherParser::ExpressionContext *CypherParser::SetItemContext::expression() {
+CypherParser::ExpressionContext* CypherParser::SetItemContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
-CypherParser::VariableContext *CypherParser::SetItemContext::variable() {
+std::vector<tree::TerminalNode *> CypherParser::SetItemContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::SetItemContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+CypherParser::VariableContext* CypherParser::SetItemContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
-CypherParser::NodeLabelsContext *CypherParser::SetItemContext::nodeLabels() {
+CypherParser::NodeLabelsContext* CypherParser::SetItemContext::nodeLabels() {
return getRuleContext<CypherParser::NodeLabelsContext>(0);
}
+
size_t CypherParser::SetItemContext::getRuleIndex() const {
return CypherParser::RuleSetItem;
}
-void CypherParser::SetItemContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::SetItemContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterSetItem(this);
+ if (parserListener != nullptr)
+ parserListener->enterSetItem(this);
}
void CypherParser::SetItemContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitSetItem(this);
+ if (parserListener != nullptr)
+ parserListener->exitSetItem(this);
}
-antlrcpp::Any CypherParser::SetItemContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::SetItemContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitSetItem(this);
else
return visitor->visitChildren(this);
}
-CypherParser::SetItemContext *CypherParser::setItem() {
- SetItemContext *_localctx =
- _tracker.createInstance<SetItemContext>(_ctx, getState());
+CypherParser::SetItemContext* CypherParser::setItem() {
+ SetItemContext *_localctx = _tracker.createInstance<SetItemContext>(_ctx, getState());
enterRule(_localctx, 26, CypherParser::RuleSetItem);
+ size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(299);
+ setState(325);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 22, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(284);
- propertyExpression();
- setState(285);
- match(CypherParser::T__2);
- setState(286);
- expression();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(289);
+ propertyExpression();
+ setState(291);
+ _errHandler->sync(this);
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(288);
- variable();
- setState(289);
- match(CypherParser::T__2);
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
setState(290);
- expression();
- break;
+ match(CypherParser::SP);
}
+ setState(293);
+ match(CypherParser::T__2);
+ setState(295);
+ _errHandler->sync(this);
- case 3: {
- enterOuterAlt(_localctx, 3);
- setState(292);
- variable();
- setState(293);
- match(CypherParser::T__3);
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
setState(294);
- expression();
- break;
- }
-
- case 4: {
- enterOuterAlt(_localctx, 4);
- setState(296);
- variable();
- setState(297);
- nodeLabels();
- break;
+ match(CypherParser::SP);
}
+ setState(297);
+ expression();
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(299);
+ variable();
+ setState(301);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(300);
+ match(CypherParser::SP);
+ }
+ setState(303);
+ match(CypherParser::T__2);
+ setState(305);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(304);
+ match(CypherParser::SP);
+ }
+ setState(307);
+ expression();
+ break;
+ }
+
+ case 3: {
+ enterOuterAlt(_localctx, 3);
+ setState(309);
+ variable();
+ setState(311);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(310);
+ match(CypherParser::SP);
+ }
+ setState(313);
+ match(CypherParser::T__3);
+ setState(315);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(314);
+ match(CypherParser::SP);
+ }
+ setState(317);
+ expression();
+ break;
+ }
+
+ case 4: {
+ enterOuterAlt(_localctx, 4);
+ setState(319);
+ variable();
+ setState(321);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(320);
+ match(CypherParser::SP);
+ }
+ setState(323);
+ nodeLabels();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1362,28 +1473,25 @@ CypherParser::SetItemContext *CypherParser::setItem() {
return _localctx;
}
-//----------------- CypherDeleteContext
-//------------------------------------------------------------------
+//----------------- CypherDeleteContext ------------------------------------------------------------------
-CypherParser::CypherDeleteContext::CypherDeleteContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::CypherDeleteContext::CypherDeleteContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::CypherDeleteContext::DELETE() {
+tree::TerminalNode* CypherParser::CypherDeleteContext::DELETE() {
return getToken(CypherParser::DELETE, 0);
}
-std::vector<CypherParser::ExpressionContext *>
-CypherParser::CypherDeleteContext::expression() {
+std::vector<CypherParser::ExpressionContext *> CypherParser::CypherDeleteContext::expression() {
return getRuleContexts<CypherParser::ExpressionContext>();
}
-CypherParser::ExpressionContext *CypherParser::CypherDeleteContext::expression(
- size_t i) {
+CypherParser::ExpressionContext* CypherParser::CypherDeleteContext::expression(size_t i) {
return getRuleContext<CypherParser::ExpressionContext>(i);
}
-tree::TerminalNode *CypherParser::CypherDeleteContext::DETACH() {
+tree::TerminalNode* CypherParser::CypherDeleteContext::DETACH() {
return getToken(CypherParser::DETACH, 0);
}
@@ -1391,100 +1499,101 @@ std::vector<tree::TerminalNode *> CypherParser::CypherDeleteContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::CypherDeleteContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::CypherDeleteContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::CypherDeleteContext::getRuleIndex() const {
return CypherParser::RuleCypherDelete;
}
-void CypherParser::CypherDeleteContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherDeleteContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterCypherDelete(this);
+ if (parserListener != nullptr)
+ parserListener->enterCypherDelete(this);
}
-void CypherParser::CypherDeleteContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherDeleteContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitCypherDelete(this);
+ if (parserListener != nullptr)
+ parserListener->exitCypherDelete(this);
}
-antlrcpp::Any CypherParser::CypherDeleteContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::CypherDeleteContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitCypherDelete(this);
else
return visitor->visitChildren(this);
}
-CypherParser::CypherDeleteContext *CypherParser::cypherDelete() {
- CypherDeleteContext *_localctx =
- _tracker.createInstance<CypherDeleteContext>(_ctx, getState());
+CypherParser::CypherDeleteContext* CypherParser::cypherDelete() {
+ CypherDeleteContext *_localctx = _tracker.createInstance<CypherDeleteContext>(_ctx, getState());
enterRule(_localctx, 28, CypherParser::RuleCypherDelete);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(303);
+ setState(329);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::DETACH) {
- setState(301);
+ setState(327);
match(CypherParser::DETACH);
- setState(302);
+ setState(328);
match(CypherParser::SP);
}
- setState(305);
+ setState(331);
match(CypherParser::DELETE);
- setState(307);
+ setState(333);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(306);
+ setState(332);
match(CypherParser::SP);
}
- setState(309);
+ setState(335);
expression();
- setState(320);
+ setState(346);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27,
- _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(311);
+ setState(337);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(310);
+ setState(336);
match(CypherParser::SP);
}
- setState(313);
+ setState(339);
match(CypherParser::T__1);
- setState(315);
+ setState(341);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(314);
+ setState(340);
match(CypherParser::SP);
}
- setState(317);
- expression();
+ setState(343);
+ expression();
}
- setState(322);
+ setState(348);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 27, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1493,14 +1602,13 @@ CypherParser::CypherDeleteContext *CypherParser::cypherDelete() {
return _localctx;
}
-//----------------- RemoveContext
-//------------------------------------------------------------------
+//----------------- RemoveContext ------------------------------------------------------------------
-CypherParser::RemoveContext::RemoveContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::RemoveContext::RemoveContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::RemoveContext::REMOVE() {
+tree::TerminalNode* CypherParser::RemoveContext::REMOVE() {
return getToken(CypherParser::REMOVE, 0);
}
@@ -1508,92 +1616,93 @@ std::vector<tree::TerminalNode *> CypherParser::RemoveContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::RemoveContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::RemoveContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-std::vector<CypherParser::RemoveItemContext *>
-CypherParser::RemoveContext::removeItem() {
+std::vector<CypherParser::RemoveItemContext *> CypherParser::RemoveContext::removeItem() {
return getRuleContexts<CypherParser::RemoveItemContext>();
}
-CypherParser::RemoveItemContext *CypherParser::RemoveContext::removeItem(
- size_t i) {
+CypherParser::RemoveItemContext* CypherParser::RemoveContext::removeItem(size_t i) {
return getRuleContext<CypherParser::RemoveItemContext>(i);
}
+
size_t CypherParser::RemoveContext::getRuleIndex() const {
return CypherParser::RuleRemove;
}
void CypherParser::RemoveContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRemove(this);
+ if (parserListener != nullptr)
+ parserListener->enterRemove(this);
}
void CypherParser::RemoveContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRemove(this);
+ if (parserListener != nullptr)
+ parserListener->exitRemove(this);
}
-antlrcpp::Any CypherParser::RemoveContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RemoveContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRemove(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RemoveContext *CypherParser::remove() {
- RemoveContext *_localctx =
- _tracker.createInstance<RemoveContext>(_ctx, getState());
+CypherParser::RemoveContext* CypherParser::remove() {
+ RemoveContext *_localctx = _tracker.createInstance<RemoveContext>(_ctx, getState());
enterRule(_localctx, 30, CypherParser::RuleRemove);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(323);
+ setState(349);
match(CypherParser::REMOVE);
- setState(324);
+ setState(350);
match(CypherParser::SP);
- setState(325);
+ setState(351);
removeItem();
- setState(336);
+ setState(362);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30,
- _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(327);
+ setState(353);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(326);
+ setState(352);
match(CypherParser::SP);
}
- setState(329);
+ setState(355);
match(CypherParser::T__1);
- setState(331);
+ setState(357);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(330);
+ setState(356);
match(CypherParser::SP);
}
- setState(333);
- removeItem();
+ setState(359);
+ removeItem();
}
- setState(338);
+ setState(364);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 30, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1602,79 +1711,80 @@ CypherParser::RemoveContext *CypherParser::remove() {
return _localctx;
}
-//----------------- RemoveItemContext
-//------------------------------------------------------------------
+//----------------- RemoveItemContext ------------------------------------------------------------------
-CypherParser::RemoveItemContext::RemoveItemContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::RemoveItemContext::RemoveItemContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::VariableContext *CypherParser::RemoveItemContext::variable() {
+CypherParser::VariableContext* CypherParser::RemoveItemContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
-CypherParser::NodeLabelsContext *CypherParser::RemoveItemContext::nodeLabels() {
+CypherParser::NodeLabelsContext* CypherParser::RemoveItemContext::nodeLabels() {
return getRuleContext<CypherParser::NodeLabelsContext>(0);
}
-CypherParser::PropertyExpressionContext *
-CypherParser::RemoveItemContext::propertyExpression() {
+CypherParser::PropertyExpressionContext* CypherParser::RemoveItemContext::propertyExpression() {
return getRuleContext<CypherParser::PropertyExpressionContext>(0);
}
+
size_t CypherParser::RemoveItemContext::getRuleIndex() const {
return CypherParser::RuleRemoveItem;
}
-void CypherParser::RemoveItemContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RemoveItemContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRemoveItem(this);
+ if (parserListener != nullptr)
+ parserListener->enterRemoveItem(this);
}
-void CypherParser::RemoveItemContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RemoveItemContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRemoveItem(this);
+ if (parserListener != nullptr)
+ parserListener->exitRemoveItem(this);
}
-antlrcpp::Any CypherParser::RemoveItemContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RemoveItemContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRemoveItem(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RemoveItemContext *CypherParser::removeItem() {
- RemoveItemContext *_localctx =
- _tracker.createInstance<RemoveItemContext>(_ctx, getState());
+CypherParser::RemoveItemContext* CypherParser::removeItem() {
+ RemoveItemContext *_localctx = _tracker.createInstance<RemoveItemContext>(_ctx, getState());
enterRule(_localctx, 32, CypherParser::RuleRemoveItem);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(343);
+ setState(369);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 31, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(339);
- variable();
- setState(340);
- nodeLabels();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(342);
- propertyExpression();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(365);
+ variable();
+ setState(366);
+ nodeLabels();
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(368);
+ propertyExpression();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1683,14 +1793,13 @@ CypherParser::RemoveItemContext *CypherParser::removeItem() {
return _localctx;
}
-//----------------- WithContext
-//------------------------------------------------------------------
+//----------------- WithContext ------------------------------------------------------------------
-CypherParser::WithContext::WithContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::WithContext::WithContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::WithContext::WITH() {
+tree::TerminalNode* CypherParser::WithContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
@@ -1698,99 +1807,104 @@ std::vector<tree::TerminalNode *> CypherParser::WithContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::WithContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::WithContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::ReturnBodyContext *CypherParser::WithContext::returnBody() {
+CypherParser::ReturnBodyContext* CypherParser::WithContext::returnBody() {
return getRuleContext<CypherParser::ReturnBodyContext>(0);
}
-tree::TerminalNode *CypherParser::WithContext::DISTINCT() {
+tree::TerminalNode* CypherParser::WithContext::DISTINCT() {
return getToken(CypherParser::DISTINCT, 0);
}
-CypherParser::WhereContext *CypherParser::WithContext::where() {
+CypherParser::WhereContext* CypherParser::WithContext::where() {
return getRuleContext<CypherParser::WhereContext>(0);
}
+
size_t CypherParser::WithContext::getRuleIndex() const {
return CypherParser::RuleWith;
}
void CypherParser::WithContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterWith(this);
+ if (parserListener != nullptr)
+ parserListener->enterWith(this);
}
void CypherParser::WithContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitWith(this);
+ if (parserListener != nullptr)
+ parserListener->exitWith(this);
}
-antlrcpp::Any CypherParser::WithContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::WithContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitWith(this);
else
return visitor->visitChildren(this);
}
-CypherParser::WithContext *CypherParser::with() {
- WithContext *_localctx =
- _tracker.createInstance<WithContext>(_ctx, getState());
+CypherParser::WithContext* CypherParser::with() {
+ WithContext *_localctx = _tracker.createInstance<WithContext>(_ctx, getState());
enterRule(_localctx, 34, CypherParser::RuleWith);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(345);
+ setState(371);
match(CypherParser::WITH);
- setState(350);
+ setState(376);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 33, _ctx)) {
- case 1: {
- setState(347);
- _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
+ case 1: {
+ setState(373);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(346);
- match(CypherParser::SP);
- }
- setState(349);
- match(CypherParser::DISTINCT);
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(372);
+ match(CypherParser::SP);
}
+ setState(375);
+ match(CypherParser::DISTINCT);
+ break;
}
- setState(352);
+
+ }
+ setState(378);
match(CypherParser::SP);
- setState(353);
+ setState(379);
returnBody();
- setState(358);
+ setState(384);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 35, _ctx)) {
- case 1: {
- setState(355);
- _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx)) {
+ case 1: {
+ setState(381);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(354);
- match(CypherParser::SP);
- }
- setState(357);
- where();
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(380);
+ match(CypherParser::SP);
}
+ setState(383);
+ where();
+ break;
}
- } catch (RecognitionException &e) {
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1799,14 +1913,13 @@ CypherParser::WithContext *CypherParser::with() {
return _localctx;
}
-//----------------- CypherReturnContext
-//------------------------------------------------------------------
+//----------------- CypherReturnContext ------------------------------------------------------------------
-CypherParser::CypherReturnContext::CypherReturnContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::CypherReturnContext::CypherReturnContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::CypherReturnContext::RETURN() {
+tree::TerminalNode* CypherParser::CypherReturnContext::RETURN() {
return getToken(CypherParser::RETURN, 0);
}
@@ -1814,79 +1927,81 @@ std::vector<tree::TerminalNode *> CypherParser::CypherReturnContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::CypherReturnContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::CypherReturnContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::ReturnBodyContext *
-CypherParser::CypherReturnContext::returnBody() {
+CypherParser::ReturnBodyContext* CypherParser::CypherReturnContext::returnBody() {
return getRuleContext<CypherParser::ReturnBodyContext>(0);
}
-tree::TerminalNode *CypherParser::CypherReturnContext::DISTINCT() {
+tree::TerminalNode* CypherParser::CypherReturnContext::DISTINCT() {
return getToken(CypherParser::DISTINCT, 0);
}
+
size_t CypherParser::CypherReturnContext::getRuleIndex() const {
return CypherParser::RuleCypherReturn;
}
-void CypherParser::CypherReturnContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherReturnContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterCypherReturn(this);
+ if (parserListener != nullptr)
+ parserListener->enterCypherReturn(this);
}
-void CypherParser::CypherReturnContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::CypherReturnContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitCypherReturn(this);
+ if (parserListener != nullptr)
+ parserListener->exitCypherReturn(this);
}
-antlrcpp::Any CypherParser::CypherReturnContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::CypherReturnContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitCypherReturn(this);
else
return visitor->visitChildren(this);
}
-CypherParser::CypherReturnContext *CypherParser::cypherReturn() {
- CypherReturnContext *_localctx =
- _tracker.createInstance<CypherReturnContext>(_ctx, getState());
+CypherParser::CypherReturnContext* CypherParser::cypherReturn() {
+ CypherReturnContext *_localctx = _tracker.createInstance<CypherReturnContext>(_ctx, getState());
enterRule(_localctx, 36, CypherParser::RuleCypherReturn);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(360);
+ setState(386);
match(CypherParser::RETURN);
- setState(365);
+ setState(391);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 37, _ctx)) {
- case 1: {
- setState(362);
- _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx)) {
+ case 1: {
+ setState(388);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(361);
- match(CypherParser::SP);
- }
- setState(364);
- match(CypherParser::DISTINCT);
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(387);
+ match(CypherParser::SP);
}
+ setState(390);
+ match(CypherParser::DISTINCT);
+ break;
}
- setState(367);
- match(CypherParser::SP);
- setState(368);
- returnBody();
- } catch (RecognitionException &e) {
+ }
+ setState(393);
+ match(CypherParser::SP);
+ setState(394);
+ returnBody();
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -1895,15 +2010,13 @@ CypherParser::CypherReturnContext *CypherParser::cypherReturn() {
return _localctx;
}
-//----------------- ReturnBodyContext
-//------------------------------------------------------------------
+//----------------- ReturnBodyContext ------------------------------------------------------------------
-CypherParser::ReturnBodyContext::ReturnBodyContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::ReturnBodyContext::ReturnBodyContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::ReturnItemsContext *
-CypherParser::ReturnBodyContext::returnItems() {
+CypherParser::ReturnItemsContext* CypherParser::ReturnBodyContext::returnItems() {
return getRuleContext<CypherParser::ReturnItemsContext>(0);
}
@@ -1911,97 +2024,100 @@ std::vector<tree::TerminalNode *> CypherParser::ReturnBodyContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::ReturnBodyContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::ReturnBodyContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::OrderContext *CypherParser::ReturnBodyContext::order() {
+CypherParser::OrderContext* CypherParser::ReturnBodyContext::order() {
return getRuleContext<CypherParser::OrderContext>(0);
}
-CypherParser::SkipContext *CypherParser::ReturnBodyContext::skip() {
+CypherParser::SkipContext* CypherParser::ReturnBodyContext::skip() {
return getRuleContext<CypherParser::SkipContext>(0);
}
-CypherParser::LimitContext *CypherParser::ReturnBodyContext::limit() {
+CypherParser::LimitContext* CypherParser::ReturnBodyContext::limit() {
return getRuleContext<CypherParser::LimitContext>(0);
}
+
size_t CypherParser::ReturnBodyContext::getRuleIndex() const {
return CypherParser::RuleReturnBody;
}
-void CypherParser::ReturnBodyContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ReturnBodyContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterReturnBody(this);
+ if (parserListener != nullptr)
+ parserListener->enterReturnBody(this);
}
-void CypherParser::ReturnBodyContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ReturnBodyContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitReturnBody(this);
+ if (parserListener != nullptr)
+ parserListener->exitReturnBody(this);
}
-antlrcpp::Any CypherParser::ReturnBodyContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::ReturnBodyContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitReturnBody(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ReturnBodyContext *CypherParser::returnBody() {
- ReturnBodyContext *_localctx =
- _tracker.createInstance<ReturnBodyContext>(_ctx, getState());
+CypherParser::ReturnBodyContext* CypherParser::returnBody() {
+ ReturnBodyContext *_localctx = _tracker.createInstance<ReturnBodyContext>(_ctx, getState());
enterRule(_localctx, 38, CypherParser::RuleReturnBody);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(370);
+ setState(396);
returnItems();
- setState(373);
+ setState(399);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 38, _ctx)) {
- case 1: {
- setState(371);
- match(CypherParser::SP);
- setState(372);
- order();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx)) {
+ case 1: {
+ setState(397);
+ match(CypherParser::SP);
+ setState(398);
+ order();
+ break;
}
- setState(377);
+
+ }
+ setState(403);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 39, _ctx)) {
- case 1: {
- setState(375);
- match(CypherParser::SP);
- setState(376);
- skip();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
+ case 1: {
+ setState(401);
+ match(CypherParser::SP);
+ setState(402);
+ skip();
+ break;
}
- setState(381);
+
+ }
+ setState(407);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 40, _ctx)) {
- case 1: {
- setState(379);
- match(CypherParser::SP);
- setState(380);
- limit();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
+ case 1: {
+ setState(405);
+ match(CypherParser::SP);
+ setState(406);
+ limit();
+ break;
}
- } catch (RecognitionException &e) {
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2010,20 +2126,17 @@ CypherParser::ReturnBodyContext *CypherParser::returnBody() {
return _localctx;
}
-//----------------- ReturnItemsContext
-//------------------------------------------------------------------
+//----------------- ReturnItemsContext ------------------------------------------------------------------
-CypherParser::ReturnItemsContext::ReturnItemsContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::ReturnItemsContext::ReturnItemsContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::ReturnItemContext *>
-CypherParser::ReturnItemsContext::returnItem() {
+std::vector<CypherParser::ReturnItemContext *> CypherParser::ReturnItemsContext::returnItem() {
return getRuleContexts<CypherParser::ReturnItemContext>();
}
-CypherParser::ReturnItemContext *CypherParser::ReturnItemsContext::returnItem(
- size_t i) {
+CypherParser::ReturnItemContext* CypherParser::ReturnItemsContext::returnItem(size_t i) {
return getRuleContext<CypherParser::ReturnItemContext>(i);
}
@@ -2031,91 +2144,91 @@ std::vector<tree::TerminalNode *> CypherParser::ReturnItemsContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::ReturnItemsContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::ReturnItemsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::ReturnItemsContext::getRuleIndex() const {
return CypherParser::RuleReturnItems;
}
-void CypherParser::ReturnItemsContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ReturnItemsContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterReturnItems(this);
+ if (parserListener != nullptr)
+ parserListener->enterReturnItems(this);
}
-void CypherParser::ReturnItemsContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ReturnItemsContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitReturnItems(this);
+ if (parserListener != nullptr)
+ parserListener->exitReturnItems(this);
}
-antlrcpp::Any CypherParser::ReturnItemsContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::ReturnItemsContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitReturnItems(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ReturnItemsContext *CypherParser::returnItems() {
- ReturnItemsContext *_localctx =
- _tracker.createInstance<ReturnItemsContext>(_ctx, getState());
+CypherParser::ReturnItemsContext* CypherParser::returnItems() {
+ ReturnItemsContext *_localctx = _tracker.createInstance<ReturnItemsContext>(_ctx, getState());
enterRule(_localctx, 40, CypherParser::RuleReturnItems);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
- setState(411);
+ setState(437);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::T__4: {
enterOuterAlt(_localctx, 1);
- setState(383);
+ setState(409);
match(CypherParser::T__4);
- setState(394);
+ setState(420);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 43, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(385);
+ setState(411);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(384);
+ setState(410);
match(CypherParser::SP);
}
- setState(387);
+ setState(413);
match(CypherParser::T__1);
- setState(389);
+ setState(415);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(388);
+ setState(414);
match(CypherParser::SP);
}
- setState(391);
- returnItem();
+ setState(417);
+ returnItem();
}
- setState(396);
+ setState(422);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 43, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx);
}
break;
}
case CypherParser::T__5:
case CypherParser::T__7:
+ case CypherParser::T__12:
case CypherParser::T__13:
- case CypherParser::T__14:
+ case CypherParser::T__25:
case CypherParser::T__27:
- case CypherParser::T__29:
case CypherParser::StringLiteral:
case CypherParser::HexInteger:
case CypherParser::DecimalInteger:
@@ -2169,48 +2282,47 @@ CypherParser::ReturnItemsContext *CypherParser::returnItems() {
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
enterOuterAlt(_localctx, 2);
- setState(397);
+ setState(423);
returnItem();
- setState(408);
+ setState(434);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 46, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(399);
+ setState(425);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(398);
+ setState(424);
match(CypherParser::SP);
}
- setState(401);
+ setState(427);
match(CypherParser::T__1);
- setState(403);
+ setState(429);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(402);
+ setState(428);
match(CypherParser::SP);
}
- setState(405);
- returnItem();
+ setState(431);
+ returnItem();
}
- setState(410);
+ setState(436);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 46, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx);
}
break;
}
- default:
- throw NoViableAltException(this);
+ default:
+ throw NoViableAltException(this);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2219,14 +2331,13 @@ CypherParser::ReturnItemsContext *CypherParser::returnItems() {
return _localctx;
}
-//----------------- ReturnItemContext
-//------------------------------------------------------------------
+//----------------- ReturnItemContext ------------------------------------------------------------------
-CypherParser::ReturnItemContext::ReturnItemContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::ReturnItemContext::ReturnItemContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::ExpressionContext *CypherParser::ReturnItemContext::expression() {
+CypherParser::ExpressionContext* CypherParser::ReturnItemContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
@@ -2234,77 +2345,80 @@ std::vector<tree::TerminalNode *> CypherParser::ReturnItemContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::ReturnItemContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::ReturnItemContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-tree::TerminalNode *CypherParser::ReturnItemContext::AS() {
+tree::TerminalNode* CypherParser::ReturnItemContext::AS() {
return getToken(CypherParser::AS, 0);
}
-CypherParser::VariableContext *CypherParser::ReturnItemContext::variable() {
+CypherParser::VariableContext* CypherParser::ReturnItemContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
+
size_t CypherParser::ReturnItemContext::getRuleIndex() const {
return CypherParser::RuleReturnItem;
}
-void CypherParser::ReturnItemContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ReturnItemContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterReturnItem(this);
+ if (parserListener != nullptr)
+ parserListener->enterReturnItem(this);
}
-void CypherParser::ReturnItemContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ReturnItemContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitReturnItem(this);
+ if (parserListener != nullptr)
+ parserListener->exitReturnItem(this);
}
-antlrcpp::Any CypherParser::ReturnItemContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::ReturnItemContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitReturnItem(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ReturnItemContext *CypherParser::returnItem() {
- ReturnItemContext *_localctx =
- _tracker.createInstance<ReturnItemContext>(_ctx, getState());
+CypherParser::ReturnItemContext* CypherParser::returnItem() {
+ ReturnItemContext *_localctx = _tracker.createInstance<ReturnItemContext>(_ctx, getState());
enterRule(_localctx, 42, CypherParser::RuleReturnItem);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(420);
+ setState(446);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 48, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(413);
- expression();
- setState(414);
- match(CypherParser::SP);
- setState(415);
- match(CypherParser::AS);
- setState(416);
- match(CypherParser::SP);
- setState(417);
- variable();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(419);
- expression();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(439);
+ expression();
+ setState(440);
+ match(CypherParser::SP);
+ setState(441);
+ match(CypherParser::AS);
+ setState(442);
+ match(CypherParser::SP);
+ setState(443);
+ variable();
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(445);
+ expression();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2313,14 +2427,13 @@ CypherParser::ReturnItemContext *CypherParser::returnItem() {
return _localctx;
}
-//----------------- OrderContext
-//------------------------------------------------------------------
+//----------------- OrderContext ------------------------------------------------------------------
-CypherParser::OrderContext::OrderContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::OrderContext::OrderContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::OrderContext::ORDER() {
+tree::TerminalNode* CypherParser::OrderContext::ORDER() {
return getToken(CypherParser::ORDER, 0);
}
@@ -2328,86 +2441,90 @@ std::vector<tree::TerminalNode *> CypherParser::OrderContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::OrderContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::OrderContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-tree::TerminalNode *CypherParser::OrderContext::BY() {
+tree::TerminalNode* CypherParser::OrderContext::BY() {
return getToken(CypherParser::BY, 0);
}
-std::vector<CypherParser::SortItemContext *>
-CypherParser::OrderContext::sortItem() {
+std::vector<CypherParser::SortItemContext *> CypherParser::OrderContext::sortItem() {
return getRuleContexts<CypherParser::SortItemContext>();
}
-CypherParser::SortItemContext *CypherParser::OrderContext::sortItem(size_t i) {
+CypherParser::SortItemContext* CypherParser::OrderContext::sortItem(size_t i) {
return getRuleContext<CypherParser::SortItemContext>(i);
}
+
size_t CypherParser::OrderContext::getRuleIndex() const {
return CypherParser::RuleOrder;
}
void CypherParser::OrderContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterOrder(this);
+ if (parserListener != nullptr)
+ parserListener->enterOrder(this);
}
void CypherParser::OrderContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitOrder(this);
+ if (parserListener != nullptr)
+ parserListener->exitOrder(this);
}
-antlrcpp::Any CypherParser::OrderContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::OrderContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitOrder(this);
else
return visitor->visitChildren(this);
}
-CypherParser::OrderContext *CypherParser::order() {
- OrderContext *_localctx =
- _tracker.createInstance<OrderContext>(_ctx, getState());
+CypherParser::OrderContext* CypherParser::order() {
+ OrderContext *_localctx = _tracker.createInstance<OrderContext>(_ctx, getState());
enterRule(_localctx, 44, CypherParser::RuleOrder);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(422);
+ setState(448);
match(CypherParser::ORDER);
- setState(423);
+ setState(449);
match(CypherParser::SP);
- setState(424);
+ setState(450);
match(CypherParser::BY);
- setState(425);
+ setState(451);
match(CypherParser::SP);
- setState(426);
+ setState(452);
sortItem();
- setState(434);
+ setState(460);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__1) {
- setState(427);
+ setState(453);
match(CypherParser::T__1);
- setState(429);
+ setState(455);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(428);
+ setState(454);
match(CypherParser::SP);
}
- setState(431);
+ setState(457);
sortItem();
- setState(436);
+ setState(462);
_errHandler->sync(this);
_la = _input->LA(1);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2416,63 +2533,67 @@ CypherParser::OrderContext *CypherParser::order() {
return _localctx;
}
-//----------------- SkipContext
-//------------------------------------------------------------------
+//----------------- SkipContext ------------------------------------------------------------------
-CypherParser::SkipContext::SkipContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::SkipContext::SkipContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::SkipContext::L_SKIP() {
+tree::TerminalNode* CypherParser::SkipContext::L_SKIP() {
return getToken(CypherParser::L_SKIP, 0);
}
-tree::TerminalNode *CypherParser::SkipContext::SP() {
+tree::TerminalNode* CypherParser::SkipContext::SP() {
return getToken(CypherParser::SP, 0);
}
-CypherParser::ExpressionContext *CypherParser::SkipContext::expression() {
+CypherParser::ExpressionContext* CypherParser::SkipContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
+
size_t CypherParser::SkipContext::getRuleIndex() const {
return CypherParser::RuleSkip;
}
void CypherParser::SkipContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterSkip(this);
+ if (parserListener != nullptr)
+ parserListener->enterSkip(this);
}
void CypherParser::SkipContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitSkip(this);
+ if (parserListener != nullptr)
+ parserListener->exitSkip(this);
}
-antlrcpp::Any CypherParser::SkipContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::SkipContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitSkip(this);
else
return visitor->visitChildren(this);
}
-CypherParser::SkipContext *CypherParser::skip() {
- SkipContext *_localctx =
- _tracker.createInstance<SkipContext>(_ctx, getState());
+CypherParser::SkipContext* CypherParser::skip() {
+ SkipContext *_localctx = _tracker.createInstance<SkipContext>(_ctx, getState());
enterRule(_localctx, 46, CypherParser::RuleSkip);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(437);
+ setState(463);
match(CypherParser::L_SKIP);
- setState(438);
+ setState(464);
match(CypherParser::SP);
- setState(439);
+ setState(465);
expression();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2481,63 +2602,67 @@ CypherParser::SkipContext *CypherParser::skip() {
return _localctx;
}
-//----------------- LimitContext
-//------------------------------------------------------------------
+//----------------- LimitContext ------------------------------------------------------------------
-CypherParser::LimitContext::LimitContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::LimitContext::LimitContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::LimitContext::LIMIT() {
+tree::TerminalNode* CypherParser::LimitContext::LIMIT() {
return getToken(CypherParser::LIMIT, 0);
}
-tree::TerminalNode *CypherParser::LimitContext::SP() {
+tree::TerminalNode* CypherParser::LimitContext::SP() {
return getToken(CypherParser::SP, 0);
}
-CypherParser::ExpressionContext *CypherParser::LimitContext::expression() {
+CypherParser::ExpressionContext* CypherParser::LimitContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
+
size_t CypherParser::LimitContext::getRuleIndex() const {
return CypherParser::RuleLimit;
}
void CypherParser::LimitContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterLimit(this);
+ if (parserListener != nullptr)
+ parserListener->enterLimit(this);
}
void CypherParser::LimitContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitLimit(this);
+ if (parserListener != nullptr)
+ parserListener->exitLimit(this);
}
-antlrcpp::Any CypherParser::LimitContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::LimitContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitLimit(this);
else
return visitor->visitChildren(this);
}
-CypherParser::LimitContext *CypherParser::limit() {
- LimitContext *_localctx =
- _tracker.createInstance<LimitContext>(_ctx, getState());
+CypherParser::LimitContext* CypherParser::limit() {
+ LimitContext *_localctx = _tracker.createInstance<LimitContext>(_ctx, getState());
enterRule(_localctx, 48, CypherParser::RuleLimit);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(441);
+ setState(467);
match(CypherParser::LIMIT);
- setState(442);
+ setState(468);
match(CypherParser::SP);
- setState(443);
+ setState(469);
expression();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2546,104 +2671,106 @@ CypherParser::LimitContext *CypherParser::limit() {
return _localctx;
}
-//----------------- SortItemContext
-//------------------------------------------------------------------
+//----------------- SortItemContext ------------------------------------------------------------------
-CypherParser::SortItemContext::SortItemContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::SortItemContext::SortItemContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::ExpressionContext *CypherParser::SortItemContext::expression() {
+CypherParser::ExpressionContext* CypherParser::SortItemContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
-tree::TerminalNode *CypherParser::SortItemContext::ASCENDING() {
+tree::TerminalNode* CypherParser::SortItemContext::ASCENDING() {
return getToken(CypherParser::ASCENDING, 0);
}
-tree::TerminalNode *CypherParser::SortItemContext::ASC() {
+tree::TerminalNode* CypherParser::SortItemContext::ASC() {
return getToken(CypherParser::ASC, 0);
}
-tree::TerminalNode *CypherParser::SortItemContext::DESCENDING() {
+tree::TerminalNode* CypherParser::SortItemContext::DESCENDING() {
return getToken(CypherParser::DESCENDING, 0);
}
-tree::TerminalNode *CypherParser::SortItemContext::DESC() {
+tree::TerminalNode* CypherParser::SortItemContext::DESC() {
return getToken(CypherParser::DESC, 0);
}
-tree::TerminalNode *CypherParser::SortItemContext::SP() {
+tree::TerminalNode* CypherParser::SortItemContext::SP() {
return getToken(CypherParser::SP, 0);
}
+
size_t CypherParser::SortItemContext::getRuleIndex() const {
return CypherParser::RuleSortItem;
}
-void CypherParser::SortItemContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::SortItemContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterSortItem(this);
+ if (parserListener != nullptr)
+ parserListener->enterSortItem(this);
}
-void CypherParser::SortItemContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::SortItemContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitSortItem(this);
+ if (parserListener != nullptr)
+ parserListener->exitSortItem(this);
}
-antlrcpp::Any CypherParser::SortItemContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::SortItemContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitSortItem(this);
else
return visitor->visitChildren(this);
}
-CypherParser::SortItemContext *CypherParser::sortItem() {
- SortItemContext *_localctx =
- _tracker.createInstance<SortItemContext>(_ctx, getState());
+CypherParser::SortItemContext* CypherParser::sortItem() {
+ SortItemContext *_localctx = _tracker.createInstance<SortItemContext>(_ctx, getState());
enterRule(_localctx, 50, CypherParser::RuleSortItem);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(445);
+ setState(471);
expression();
- setState(450);
+ setState(476);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 52, _ctx)) {
- case 1: {
- setState(447);
- _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx)) {
+ case 1: {
+ setState(473);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(446);
- match(CypherParser::SP);
- }
- setState(449);
- _la = _input->LA(1);
- if (!(((((_la - 84) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 84)) &
- ((1ULL << (CypherParser::ASCENDING - 84)) |
- (1ULL << (CypherParser::ASC - 84)) |
- (1ULL << (CypherParser::DESCENDING - 84)) |
- (1ULL << (CypherParser::DESC - 84)))) != 0))) {
- _errHandler->recoverInline(this);
- } else {
- _errHandler->reportMatch(this);
- consume();
- }
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(472);
+ match(CypherParser::SP);
}
+ setState(475);
+ _la = _input->LA(1);
+ if (!(((((_la - 82) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 82)) & ((1ULL << (CypherParser::ASCENDING - 82))
+ | (1ULL << (CypherParser::ASC - 82))
+ | (1ULL << (CypherParser::DESCENDING - 82))
+ | (1ULL << (CypherParser::DESC - 82)))) != 0))) {
+ _errHandler->recoverInline(this);
+ }
+ else {
+ _errHandler->reportMatch(this);
+ consume();
+ }
+ break;
}
- } catch (RecognitionException &e) {
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2652,63 +2779,67 @@ CypherParser::SortItemContext *CypherParser::sortItem() {
return _localctx;
}
-//----------------- WhereContext
-//------------------------------------------------------------------
+//----------------- WhereContext ------------------------------------------------------------------
-CypherParser::WhereContext::WhereContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::WhereContext::WhereContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::WhereContext::WHERE() {
+tree::TerminalNode* CypherParser::WhereContext::WHERE() {
return getToken(CypherParser::WHERE, 0);
}
-tree::TerminalNode *CypherParser::WhereContext::SP() {
+tree::TerminalNode* CypherParser::WhereContext::SP() {
return getToken(CypherParser::SP, 0);
}
-CypherParser::ExpressionContext *CypherParser::WhereContext::expression() {
+CypherParser::ExpressionContext* CypherParser::WhereContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
+
size_t CypherParser::WhereContext::getRuleIndex() const {
return CypherParser::RuleWhere;
}
void CypherParser::WhereContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterWhere(this);
+ if (parserListener != nullptr)
+ parserListener->enterWhere(this);
}
void CypherParser::WhereContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitWhere(this);
+ if (parserListener != nullptr)
+ parserListener->exitWhere(this);
}
-antlrcpp::Any CypherParser::WhereContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::WhereContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitWhere(this);
else
return visitor->visitChildren(this);
}
-CypherParser::WhereContext *CypherParser::where() {
- WhereContext *_localctx =
- _tracker.createInstance<WhereContext>(_ctx, getState());
+CypherParser::WhereContext* CypherParser::where() {
+ WhereContext *_localctx = _tracker.createInstance<WhereContext>(_ctx, getState());
enterRule(_localctx, 52, CypherParser::RuleWhere);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(452);
+ setState(478);
match(CypherParser::WHERE);
- setState(453);
+ setState(479);
match(CypherParser::SP);
- setState(454);
+ setState(480);
expression();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2717,20 +2848,17 @@ CypherParser::WhereContext *CypherParser::where() {
return _localctx;
}
-//----------------- PatternContext
-//------------------------------------------------------------------
+//----------------- PatternContext ------------------------------------------------------------------
-CypherParser::PatternContext::PatternContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PatternContext::PatternContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::PatternPartContext *>
-CypherParser::PatternContext::patternPart() {
+std::vector<CypherParser::PatternPartContext *> CypherParser::PatternContext::patternPart() {
return getRuleContexts<CypherParser::PatternPartContext>();
}
-CypherParser::PatternPartContext *CypherParser::PatternContext::patternPart(
- size_t i) {
+CypherParser::PatternPartContext* CypherParser::PatternContext::patternPart(size_t i) {
return getRuleContext<CypherParser::PatternPartContext>(i);
}
@@ -2738,79 +2866,81 @@ std::vector<tree::TerminalNode *> CypherParser::PatternContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::PatternContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::PatternContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::PatternContext::getRuleIndex() const {
return CypherParser::RulePattern;
}
-void CypherParser::PatternContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PatternContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterPattern(this);
+ if (parserListener != nullptr)
+ parserListener->enterPattern(this);
}
void CypherParser::PatternContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitPattern(this);
+ if (parserListener != nullptr)
+ parserListener->exitPattern(this);
}
-antlrcpp::Any CypherParser::PatternContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::PatternContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitPattern(this);
else
return visitor->visitChildren(this);
}
-CypherParser::PatternContext *CypherParser::pattern() {
- PatternContext *_localctx =
- _tracker.createInstance<PatternContext>(_ctx, getState());
+CypherParser::PatternContext* CypherParser::pattern() {
+ PatternContext *_localctx = _tracker.createInstance<PatternContext>(_ctx, getState());
enterRule(_localctx, 54, CypherParser::RulePattern);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(456);
+ setState(482);
patternPart();
- setState(467);
+ setState(493);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 55,
- _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(458);
+ setState(484);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(457);
+ setState(483);
match(CypherParser::SP);
}
- setState(460);
+ setState(486);
match(CypherParser::T__1);
- setState(462);
+ setState(488);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(461);
+ setState(487);
match(CypherParser::SP);
}
- setState(464);
- patternPart();
+ setState(490);
+ patternPart();
}
- setState(469);
+ setState(495);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 55, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2819,19 +2949,17 @@ CypherParser::PatternContext *CypherParser::pattern() {
return _localctx;
}
-//----------------- PatternPartContext
-//------------------------------------------------------------------
+//----------------- PatternPartContext ------------------------------------------------------------------
-CypherParser::PatternPartContext::PatternPartContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PatternPartContext::PatternPartContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::VariableContext *CypherParser::PatternPartContext::variable() {
+CypherParser::VariableContext* CypherParser::PatternPartContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
-CypherParser::AnonymousPatternPartContext *
-CypherParser::PatternPartContext::anonymousPatternPart() {
+CypherParser::AnonymousPatternPartContext* CypherParser::PatternPartContext::anonymousPatternPart() {
return getRuleContext<CypherParser::AnonymousPatternPartContext>(0);
}
@@ -2839,43 +2967,45 @@ std::vector<tree::TerminalNode *> CypherParser::PatternPartContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::PatternPartContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::PatternPartContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::PatternPartContext::getRuleIndex() const {
return CypherParser::RulePatternPart;
}
-void CypherParser::PatternPartContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PatternPartContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterPatternPart(this);
+ if (parserListener != nullptr)
+ parserListener->enterPatternPart(this);
}
-void CypherParser::PatternPartContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PatternPartContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitPatternPart(this);
+ if (parserListener != nullptr)
+ parserListener->exitPatternPart(this);
}
-antlrcpp::Any CypherParser::PatternPartContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::PatternPartContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitPatternPart(this);
else
return visitor->visitChildren(this);
}
-CypherParser::PatternPartContext *CypherParser::patternPart() {
- PatternPartContext *_localctx =
- _tracker.createInstance<PatternPartContext>(_ctx, getState());
+CypherParser::PatternPartContext* CypherParser::patternPart() {
+ PatternPartContext *_localctx = _tracker.createInstance<PatternPartContext>(_ctx, getState());
enterRule(_localctx, 56, CypherParser::RulePatternPart);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(481);
+ setState(507);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::HexLetter:
@@ -2925,43 +3055,44 @@ CypherParser::PatternPartContext *CypherParser::patternPart() {
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
enterOuterAlt(_localctx, 1);
- setState(470);
+ setState(496);
variable();
- setState(472);
+ setState(498);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(471);
+ setState(497);
match(CypherParser::SP);
}
- setState(474);
+ setState(500);
match(CypherParser::T__2);
- setState(476);
+ setState(502);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(475);
+ setState(501);
match(CypherParser::SP);
}
- setState(478);
+ setState(504);
anonymousPatternPart();
break;
}
case CypherParser::T__5: {
enterOuterAlt(_localctx, 2);
- setState(480);
+ setState(506);
anonymousPatternPart();
break;
}
- default:
- throw NoViableAltException(this);
+ default:
+ throw NoViableAltException(this);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -2970,56 +3101,55 @@ CypherParser::PatternPartContext *CypherParser::patternPart() {
return _localctx;
}
-//----------------- AnonymousPatternPartContext
-//------------------------------------------------------------------
+//----------------- AnonymousPatternPartContext ------------------------------------------------------------------
-CypherParser::AnonymousPatternPartContext::AnonymousPatternPartContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::AnonymousPatternPartContext::AnonymousPatternPartContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::PatternElementContext *
-CypherParser::AnonymousPatternPartContext::patternElement() {
+CypherParser::PatternElementContext* CypherParser::AnonymousPatternPartContext::patternElement() {
return getRuleContext<CypherParser::PatternElementContext>(0);
}
+
size_t CypherParser::AnonymousPatternPartContext::getRuleIndex() const {
return CypherParser::RuleAnonymousPatternPart;
}
-void CypherParser::AnonymousPatternPartContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::AnonymousPatternPartContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
if (parserListener != nullptr)
parserListener->enterAnonymousPatternPart(this);
}
-void CypherParser::AnonymousPatternPartContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::AnonymousPatternPartContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitAnonymousPatternPart(this);
+ if (parserListener != nullptr)
+ parserListener->exitAnonymousPatternPart(this);
}
-antlrcpp::Any CypherParser::AnonymousPatternPartContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::AnonymousPatternPartContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitAnonymousPatternPart(this);
else
return visitor->visitChildren(this);
}
-CypherParser::AnonymousPatternPartContext *
-CypherParser::anonymousPatternPart() {
- AnonymousPatternPartContext *_localctx =
- _tracker.createInstance<AnonymousPatternPartContext>(_ctx, getState());
+CypherParser::AnonymousPatternPartContext* CypherParser::anonymousPatternPart() {
+ AnonymousPatternPartContext *_localctx = _tracker.createInstance<AnonymousPatternPartContext>(_ctx, getState());
enterRule(_localctx, 58, CypherParser::RuleAnonymousPatternPart);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(483);
+ setState(509);
patternElement();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -3028,25 +3158,21 @@ CypherParser::anonymousPatternPart() {
return _localctx;
}
-//----------------- PatternElementContext
-//------------------------------------------------------------------
+//----------------- PatternElementContext ------------------------------------------------------------------
-CypherParser::PatternElementContext::PatternElementContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PatternElementContext::PatternElementContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::NodePatternContext *
-CypherParser::PatternElementContext::nodePattern() {
+CypherParser::NodePatternContext* CypherParser::PatternElementContext::nodePattern() {
return getRuleContext<CypherParser::NodePatternContext>(0);
}
-std::vector<CypherParser::PatternElementChainContext *>
-CypherParser::PatternElementContext::patternElementChain() {
+std::vector<CypherParser::PatternElementChainContext *> CypherParser::PatternElementContext::patternElementChain() {
return getRuleContexts<CypherParser::PatternElementChainContext>();
}
-CypherParser::PatternElementChainContext *
-CypherParser::PatternElementContext::patternElementChain(size_t i) {
+CypherParser::PatternElementChainContext* CypherParser::PatternElementContext::patternElementChain(size_t i) {
return getRuleContext<CypherParser::PatternElementChainContext>(i);
}
@@ -3054,94 +3180,94 @@ std::vector<tree::TerminalNode *> CypherParser::PatternElementContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::PatternElementContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::PatternElementContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::PatternElementContext *
-CypherParser::PatternElementContext::patternElement() {
+CypherParser::PatternElementContext* CypherParser::PatternElementContext::patternElement() {
return getRuleContext<CypherParser::PatternElementContext>(0);
}
+
size_t CypherParser::PatternElementContext::getRuleIndex() const {
return CypherParser::RulePatternElement;
}
-void CypherParser::PatternElementContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PatternElementContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterPatternElement(this);
+ if (parserListener != nullptr)
+ parserListener->enterPatternElement(this);
}
-void CypherParser::PatternElementContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PatternElementContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitPatternElement(this);
+ if (parserListener != nullptr)
+ parserListener->exitPatternElement(this);
}
-antlrcpp::Any CypherParser::PatternElementContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::PatternElementContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitPatternElement(this);
else
return visitor->visitChildren(this);
}
-CypherParser::PatternElementContext *CypherParser::patternElement() {
- PatternElementContext *_localctx =
- _tracker.createInstance<PatternElementContext>(_ctx, getState());
+CypherParser::PatternElementContext* CypherParser::patternElement() {
+ PatternElementContext *_localctx = _tracker.createInstance<PatternElementContext>(_ctx, getState());
enterRule(_localctx, 60, CypherParser::RulePatternElement);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
- setState(499);
+ setState(525);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 61, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(485);
- nodePattern();
- setState(492);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 60, _ctx);
- while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
- if (alt == 1) {
- setState(487);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(486);
- match(CypherParser::SP);
- }
- setState(489);
- patternElementChain();
- }
- setState(494);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(511);
+ nodePattern();
+ setState(518);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx);
+ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
+ if (alt == 1) {
+ setState(513);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 60, _ctx);
- }
- break;
- }
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(495);
- match(CypherParser::T__5);
- setState(496);
- patternElement();
- setState(497);
- match(CypherParser::T__6);
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(512);
+ match(CypherParser::SP);
+ }
+ setState(515);
+ patternElementChain();
+ }
+ setState(520);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx);
}
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(521);
+ match(CypherParser::T__5);
+ setState(522);
+ patternElement();
+ setState(523);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -3150,179 +3276,178 @@ CypherParser::PatternElementContext *CypherParser::patternElement() {
return _localctx;
}
-//----------------- NodePatternContext
-//------------------------------------------------------------------
+//----------------- NodePatternContext ------------------------------------------------------------------
-CypherParser::NodePatternContext::NodePatternContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::NodePatternContext::NodePatternContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
std::vector<tree::TerminalNode *> CypherParser::NodePatternContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::NodePatternContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::NodePatternContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::VariableContext *CypherParser::NodePatternContext::variable() {
+CypherParser::VariableContext* CypherParser::NodePatternContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
-CypherParser::NodeLabelsContext *
-CypherParser::NodePatternContext::nodeLabels() {
+CypherParser::NodeLabelsContext* CypherParser::NodePatternContext::nodeLabels() {
return getRuleContext<CypherParser::NodeLabelsContext>(0);
}
-CypherParser::PropertiesContext *
-CypherParser::NodePatternContext::properties() {
+CypherParser::PropertiesContext* CypherParser::NodePatternContext::properties() {
return getRuleContext<CypherParser::PropertiesContext>(0);
}
+
size_t CypherParser::NodePatternContext::getRuleIndex() const {
return CypherParser::RuleNodePattern;
}
-void CypherParser::NodePatternContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::NodePatternContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterNodePattern(this);
+ if (parserListener != nullptr)
+ parserListener->enterNodePattern(this);
}
-void CypherParser::NodePatternContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::NodePatternContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitNodePattern(this);
+ if (parserListener != nullptr)
+ parserListener->exitNodePattern(this);
}
-antlrcpp::Any CypherParser::NodePatternContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::NodePatternContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitNodePattern(this);
else
return visitor->visitChildren(this);
}
-CypherParser::NodePatternContext *CypherParser::nodePattern() {
- NodePatternContext *_localctx =
- _tracker.createInstance<NodePatternContext>(_ctx, getState());
+CypherParser::NodePatternContext* CypherParser::nodePattern() {
+ NodePatternContext *_localctx = _tracker.createInstance<NodePatternContext>(_ctx, getState());
enterRule(_localctx, 62, CypherParser::RuleNodePattern);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(501);
+ setState(527);
match(CypherParser::T__5);
- setState(503);
+ setState(529);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(502);
+ setState(528);
match(CypherParser::SP);
}
- setState(509);
+ setState(535);
_errHandler->sync(this);
_la = _input->LA(1);
- if (((((_la - 55) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 55)) &
- ((1ULL << (CypherParser::HexLetter - 55)) |
- (1ULL << (CypherParser::UNION - 55)) |
- (1ULL << (CypherParser::ALL - 55)) |
- (1ULL << (CypherParser::OPTIONAL - 55)) |
- (1ULL << (CypherParser::MATCH - 55)) |
- (1ULL << (CypherParser::UNWIND - 55)) |
- (1ULL << (CypherParser::AS - 55)) |
- (1ULL << (CypherParser::MERGE - 55)) |
- (1ULL << (CypherParser::ON - 55)) |
- (1ULL << (CypherParser::CREATE - 55)) |
- (1ULL << (CypherParser::SET - 55)) |
- (1ULL << (CypherParser::DETACH - 55)) |
- (1ULL << (CypherParser::DELETE - 55)) |
- (1ULL << (CypherParser::REMOVE - 55)) |
- (1ULL << (CypherParser::WITH - 55)) |
- (1ULL << (CypherParser::DISTINCT - 55)) |
- (1ULL << (CypherParser::RETURN - 55)) |
- (1ULL << (CypherParser::ORDER - 55)) |
- (1ULL << (CypherParser::BY - 55)) |
- (1ULL << (CypherParser::L_SKIP - 55)) |
- (1ULL << (CypherParser::LIMIT - 55)) |
- (1ULL << (CypherParser::ASCENDING - 55)) |
- (1ULL << (CypherParser::ASC - 55)) |
- (1ULL << (CypherParser::DESCENDING - 55)) |
- (1ULL << (CypherParser::DESC - 55)) |
- (1ULL << (CypherParser::WHERE - 55)) |
- (1ULL << (CypherParser::OR - 55)) |
- (1ULL << (CypherParser::XOR - 55)) |
- (1ULL << (CypherParser::AND - 55)) |
- (1ULL << (CypherParser::NOT - 55)) |
- (1ULL << (CypherParser::IN - 55)) |
- (1ULL << (CypherParser::STARTS - 55)) |
- (1ULL << (CypherParser::ENDS - 55)) |
- (1ULL << (CypherParser::CONTAINS - 55)) |
- (1ULL << (CypherParser::IS - 55)) |
- (1ULL << (CypherParser::CYPHERNULL - 55)) |
- (1ULL << (CypherParser::COUNT - 55)) |
- (1ULL << (CypherParser::FILTER - 55)) |
- (1ULL << (CypherParser::EXTRACT - 55)) |
- (1ULL << (CypherParser::ANY - 55)) |
- (1ULL << (CypherParser::NONE - 55)) |
- (1ULL << (CypherParser::SINGLE - 55)) |
- (1ULL << (CypherParser::TRUE - 55)) |
- (1ULL << (CypherParser::FALSE - 55)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 55)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 55)))) != 0)) {
- setState(505);
+ if (((((_la - 53) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
+ | (1ULL << (CypherParser::UNION - 53))
+ | (1ULL << (CypherParser::ALL - 53))
+ | (1ULL << (CypherParser::OPTIONAL - 53))
+ | (1ULL << (CypherParser::MATCH - 53))
+ | (1ULL << (CypherParser::UNWIND - 53))
+ | (1ULL << (CypherParser::AS - 53))
+ | (1ULL << (CypherParser::MERGE - 53))
+ | (1ULL << (CypherParser::ON - 53))
+ | (1ULL << (CypherParser::CREATE - 53))
+ | (1ULL << (CypherParser::SET - 53))
+ | (1ULL << (CypherParser::DETACH - 53))
+ | (1ULL << (CypherParser::DELETE - 53))
+ | (1ULL << (CypherParser::REMOVE - 53))
+ | (1ULL << (CypherParser::WITH - 53))
+ | (1ULL << (CypherParser::DISTINCT - 53))
+ | (1ULL << (CypherParser::RETURN - 53))
+ | (1ULL << (CypherParser::ORDER - 53))
+ | (1ULL << (CypherParser::BY - 53))
+ | (1ULL << (CypherParser::L_SKIP - 53))
+ | (1ULL << (CypherParser::LIMIT - 53))
+ | (1ULL << (CypherParser::ASCENDING - 53))
+ | (1ULL << (CypherParser::ASC - 53))
+ | (1ULL << (CypherParser::DESCENDING - 53))
+ | (1ULL << (CypherParser::DESC - 53))
+ | (1ULL << (CypherParser::WHERE - 53))
+ | (1ULL << (CypherParser::OR - 53))
+ | (1ULL << (CypherParser::XOR - 53))
+ | (1ULL << (CypherParser::AND - 53))
+ | (1ULL << (CypherParser::NOT - 53))
+ | (1ULL << (CypherParser::IN - 53))
+ | (1ULL << (CypherParser::STARTS - 53))
+ | (1ULL << (CypherParser::ENDS - 53))
+ | (1ULL << (CypherParser::CONTAINS - 53))
+ | (1ULL << (CypherParser::IS - 53))
+ | (1ULL << (CypherParser::CYPHERNULL - 53))
+ | (1ULL << (CypherParser::COUNT - 53))
+ | (1ULL << (CypherParser::FILTER - 53))
+ | (1ULL << (CypherParser::EXTRACT - 53))
+ | (1ULL << (CypherParser::ANY - 53))
+ | (1ULL << (CypherParser::NONE - 53))
+ | (1ULL << (CypherParser::SINGLE - 53))
+ | (1ULL << (CypherParser::TRUE - 53))
+ | (1ULL << (CypherParser::FALSE - 53))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
+ setState(531);
variable();
- setState(507);
+ setState(533);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(506);
+ setState(532);
match(CypherParser::SP);
}
}
- setState(515);
+ setState(541);
_errHandler->sync(this);
_la = _input->LA(1);
- if (_la == CypherParser::T__10) {
- setState(511);
+ if (_la == CypherParser::T__9) {
+ setState(537);
nodeLabels();
- setState(513);
+ setState(539);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(512);
+ setState(538);
match(CypherParser::SP);
}
}
- setState(521);
+ setState(547);
_errHandler->sync(this);
_la = _input->LA(1);
- if (_la == CypherParser::T__27
+ if (_la == CypherParser::T__25
- || _la == CypherParser::T__29) {
- setState(517);
+ || _la == CypherParser::T__27) {
+ setState(543);
properties();
- setState(519);
+ setState(545);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(518);
+ setState(544);
match(CypherParser::SP);
}
}
- setState(523);
+ setState(549);
match(CypherParser::T__6);
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -3331,74 +3456,74 @@ CypherParser::NodePatternContext *CypherParser::nodePattern() {
return _localctx;
}
-//----------------- PatternElementChainContext
-//------------------------------------------------------------------
+//----------------- PatternElementChainContext ------------------------------------------------------------------
-CypherParser::PatternElementChainContext::PatternElementChainContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PatternElementChainContext::PatternElementChainContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::RelationshipPatternContext *
-CypherParser::PatternElementChainContext::relationshipPattern() {
+CypherParser::RelationshipPatternContext* CypherParser::PatternElementChainContext::relationshipPattern() {
return getRuleContext<CypherParser::RelationshipPatternContext>(0);
}
-CypherParser::NodePatternContext *
-CypherParser::PatternElementChainContext::nodePattern() {
+CypherParser::NodePatternContext* CypherParser::PatternElementChainContext::nodePattern() {
return getRuleContext<CypherParser::NodePatternContext>(0);
}
-tree::TerminalNode *CypherParser::PatternElementChainContext::SP() {
+tree::TerminalNode* CypherParser::PatternElementChainContext::SP() {
return getToken(CypherParser::SP, 0);
}
+
size_t CypherParser::PatternElementChainContext::getRuleIndex() const {
return CypherParser::RulePatternElementChain;
}
-void CypherParser::PatternElementChainContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PatternElementChainContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterPatternElementChain(this);
+ if (parserListener != nullptr)
+ parserListener->enterPatternElementChain(this);
}
-void CypherParser::PatternElementChainContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PatternElementChainContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitPatternElementChain(this);
+ if (parserListener != nullptr)
+ parserListener->exitPatternElementChain(this);
}
-antlrcpp::Any CypherParser::PatternElementChainContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::PatternElementChainContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitPatternElementChain(this);
else
return visitor->visitChildren(this);
}
-CypherParser::PatternElementChainContext *CypherParser::patternElementChain() {
- PatternElementChainContext *_localctx =
- _tracker.createInstance<PatternElementChainContext>(_ctx, getState());
+CypherParser::PatternElementChainContext* CypherParser::patternElementChain() {
+ PatternElementChainContext *_localctx = _tracker.createInstance<PatternElementChainContext>(_ctx, getState());
enterRule(_localctx, 64, CypherParser::RulePatternElementChain);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(525);
+ setState(551);
relationshipPattern();
- setState(527);
+ setState(553);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(526);
+ setState(552);
match(CypherParser::SP);
}
- setState(529);
+ setState(555);
nodePattern();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -3407,269 +3532,265 @@ CypherParser::PatternElementChainContext *CypherParser::patternElementChain() {
return _localctx;
}
-//----------------- RelationshipPatternContext
-//------------------------------------------------------------------
+//----------------- RelationshipPatternContext ------------------------------------------------------------------
-CypherParser::RelationshipPatternContext::RelationshipPatternContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::RelationshipPatternContext::RelationshipPatternContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::LeftArrowHeadContext *
-CypherParser::RelationshipPatternContext::leftArrowHead() {
+CypherParser::LeftArrowHeadContext* CypherParser::RelationshipPatternContext::leftArrowHead() {
return getRuleContext<CypherParser::LeftArrowHeadContext>(0);
}
-std::vector<CypherParser::DashContext *>
-CypherParser::RelationshipPatternContext::dash() {
+std::vector<CypherParser::DashContext *> CypherParser::RelationshipPatternContext::dash() {
return getRuleContexts<CypherParser::DashContext>();
}
-CypherParser::DashContext *CypherParser::RelationshipPatternContext::dash(
- size_t i) {
+CypherParser::DashContext* CypherParser::RelationshipPatternContext::dash(size_t i) {
return getRuleContext<CypherParser::DashContext>(i);
}
-CypherParser::RightArrowHeadContext *
-CypherParser::RelationshipPatternContext::rightArrowHead() {
+CypherParser::RightArrowHeadContext* CypherParser::RelationshipPatternContext::rightArrowHead() {
return getRuleContext<CypherParser::RightArrowHeadContext>(0);
}
-std::vector<tree::TerminalNode *>
-CypherParser::RelationshipPatternContext::SP() {
+std::vector<tree::TerminalNode *> CypherParser::RelationshipPatternContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::RelationshipPatternContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::RelationshipPatternContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::RelationshipDetailContext *
-CypherParser::RelationshipPatternContext::relationshipDetail() {
+CypherParser::RelationshipDetailContext* CypherParser::RelationshipPatternContext::relationshipDetail() {
return getRuleContext<CypherParser::RelationshipDetailContext>(0);
}
+
size_t CypherParser::RelationshipPatternContext::getRuleIndex() const {
return CypherParser::RuleRelationshipPattern;
}
-void CypherParser::RelationshipPatternContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RelationshipPatternContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRelationshipPattern(this);
+ if (parserListener != nullptr)
+ parserListener->enterRelationshipPattern(this);
}
-void CypherParser::RelationshipPatternContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RelationshipPatternContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRelationshipPattern(this);
+ if (parserListener != nullptr)
+ parserListener->exitRelationshipPattern(this);
}
-antlrcpp::Any CypherParser::RelationshipPatternContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RelationshipPatternContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRelationshipPattern(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RelationshipPatternContext *CypherParser::relationshipPattern() {
- RelationshipPatternContext *_localctx =
- _tracker.createInstance<RelationshipPatternContext>(_ctx, getState());
+CypherParser::RelationshipPatternContext* CypherParser::relationshipPattern() {
+ RelationshipPatternContext *_localctx = _tracker.createInstance<RelationshipPatternContext>(_ctx, getState());
enterRule(_localctx, 66, CypherParser::RuleRelationshipPattern);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(595);
+ setState(621);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 86, _ctx)) {
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(557);
+ leftArrowHead();
+ setState(559);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(558);
+ match(CypherParser::SP);
+ }
+ setState(561);
+ dash();
+ setState(563);
+ _errHandler->sync(this);
+
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
case 1: {
- enterOuterAlt(_localctx, 1);
- setState(531);
- leftArrowHead();
- setState(533);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(532);
- match(CypherParser::SP);
- }
- setState(535);
- dash();
- setState(537);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 71, _ctx)) {
- case 1: {
- setState(536);
- match(CypherParser::SP);
- break;
- }
- }
- setState(540);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(539);
- relationshipDetail();
- }
- setState(543);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(542);
- match(CypherParser::SP);
- }
- setState(545);
- dash();
- setState(547);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(546);
- match(CypherParser::SP);
- }
- setState(549);
- rightArrowHead();
+ setState(562);
+ match(CypherParser::SP);
break;
}
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(551);
- leftArrowHead();
- setState(553);
- _errHandler->sync(this);
+ }
+ setState(566);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(552);
- match(CypherParser::SP);
- }
- setState(555);
- dash();
- setState(557);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 76, _ctx)) {
- case 1: {
- setState(556);
- match(CypherParser::SP);
- break;
- }
- }
- setState(560);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(559);
- relationshipDetail();
- }
- setState(563);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(562);
- match(CypherParser::SP);
- }
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__7) {
setState(565);
- dash();
- break;
+ relationshipDetail();
}
+ setState(569);
+ _errHandler->sync(this);
- case 3: {
- enterOuterAlt(_localctx, 3);
- setState(567);
- dash();
- setState(569);
- _errHandler->sync(this);
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(568);
+ match(CypherParser::SP);
+ }
+ setState(571);
+ dash();
+ setState(573);
+ _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 79, _ctx)) {
- case 1: {
- setState(568);
- match(CypherParser::SP);
- break;
- }
- }
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
setState(572);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(571);
- relationshipDetail();
- }
- setState(575);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(574);
- match(CypherParser::SP);
- }
- setState(577);
- dash();
- setState(579);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(578);
- match(CypherParser::SP);
- }
- setState(581);
- rightArrowHead();
- break;
- }
-
- case 4: {
- enterOuterAlt(_localctx, 4);
- setState(583);
- dash();
- setState(585);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 83, _ctx)) {
- case 1: {
- setState(584);
- match(CypherParser::SP);
- break;
- }
- }
- setState(588);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__7) {
- setState(587);
- relationshipDetail();
- }
- setState(591);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(590);
- match(CypherParser::SP);
- }
- setState(593);
- dash();
- break;
+ match(CypherParser::SP);
}
+ setState(575);
+ rightArrowHead();
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(577);
+ leftArrowHead();
+ setState(579);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(578);
+ match(CypherParser::SP);
+ }
+ setState(581);
+ dash();
+ setState(583);
+ _errHandler->sync(this);
+
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx)) {
+ case 1: {
+ setState(582);
+ match(CypherParser::SP);
+ break;
+ }
+
+ }
+ setState(586);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__7) {
+ setState(585);
+ relationshipDetail();
+ }
+ setState(589);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(588);
+ match(CypherParser::SP);
+ }
+ setState(591);
+ dash();
+ break;
+ }
+
+ case 3: {
+ enterOuterAlt(_localctx, 3);
+ setState(593);
+ dash();
+ setState(595);
+ _errHandler->sync(this);
+
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx)) {
+ case 1: {
+ setState(594);
+ match(CypherParser::SP);
+ break;
+ }
+
+ }
+ setState(598);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__7) {
+ setState(597);
+ relationshipDetail();
+ }
+ setState(601);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(600);
+ match(CypherParser::SP);
+ }
+ setState(603);
+ dash();
+ setState(605);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(604);
+ match(CypherParser::SP);
+ }
+ setState(607);
+ rightArrowHead();
+ break;
+ }
+
+ case 4: {
+ enterOuterAlt(_localctx, 4);
+ setState(609);
+ dash();
+ setState(611);
+ _errHandler->sync(this);
+
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
+ case 1: {
+ setState(610);
+ match(CypherParser::SP);
+ break;
+ }
+
+ }
+ setState(614);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__7) {
+ setState(613);
+ relationshipDetail();
+ }
+ setState(617);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(616);
+ match(CypherParser::SP);
+ }
+ setState(619);
+ dash();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -3678,329 +3799,134 @@ CypherParser::RelationshipPatternContext *CypherParser::relationshipPattern() {
return _localctx;
}
-//----------------- RelationshipDetailContext
-//------------------------------------------------------------------
+//----------------- RelationshipDetailContext ------------------------------------------------------------------
-CypherParser::RelationshipDetailContext::RelationshipDetailContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::RelationshipDetailContext::RelationshipDetailContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::VariableContext *
-CypherParser::RelationshipDetailContext::variable() {
+std::vector<tree::TerminalNode *> CypherParser::RelationshipDetailContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::RelationshipDetailContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+CypherParser::VariableContext* CypherParser::RelationshipDetailContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
-CypherParser::RelationshipTypesContext *
-CypherParser::RelationshipDetailContext::relationshipTypes() {
+CypherParser::RelationshipTypesContext* CypherParser::RelationshipDetailContext::relationshipTypes() {
return getRuleContext<CypherParser::RelationshipTypesContext>(0);
}
-CypherParser::RangeLiteralContext *
-CypherParser::RelationshipDetailContext::rangeLiteral() {
+CypherParser::RangeLiteralContext* CypherParser::RelationshipDetailContext::rangeLiteral() {
return getRuleContext<CypherParser::RangeLiteralContext>(0);
}
-CypherParser::PropertiesContext *
-CypherParser::RelationshipDetailContext::properties() {
+CypherParser::PropertiesContext* CypherParser::RelationshipDetailContext::properties() {
return getRuleContext<CypherParser::PropertiesContext>(0);
}
+
size_t CypherParser::RelationshipDetailContext::getRuleIndex() const {
return CypherParser::RuleRelationshipDetail;
}
-void CypherParser::RelationshipDetailContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RelationshipDetailContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRelationshipDetail(this);
+ if (parserListener != nullptr)
+ parserListener->enterRelationshipDetail(this);
}
-void CypherParser::RelationshipDetailContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RelationshipDetailContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRelationshipDetail(this);
+ if (parserListener != nullptr)
+ parserListener->exitRelationshipDetail(this);
}
-antlrcpp::Any CypherParser::RelationshipDetailContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RelationshipDetailContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRelationshipDetail(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RelationshipDetailContext *CypherParser::relationshipDetail() {
- RelationshipDetailContext *_localctx =
- _tracker.createInstance<RelationshipDetailContext>(_ctx, getState());
+CypherParser::RelationshipDetailContext* CypherParser::relationshipDetail() {
+ RelationshipDetailContext *_localctx = _tracker.createInstance<RelationshipDetailContext>(_ctx, getState());
enterRule(_localctx, 68, CypherParser::RuleRelationshipDetail);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(597);
+ setState(623);
match(CypherParser::T__7);
- setState(599);
+ setState(625);
_errHandler->sync(this);
_la = _input->LA(1);
- if (((((_la - 55) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 55)) &
- ((1ULL << (CypherParser::HexLetter - 55)) |
- (1ULL << (CypherParser::UNION - 55)) |
- (1ULL << (CypherParser::ALL - 55)) |
- (1ULL << (CypherParser::OPTIONAL - 55)) |
- (1ULL << (CypherParser::MATCH - 55)) |
- (1ULL << (CypherParser::UNWIND - 55)) |
- (1ULL << (CypherParser::AS - 55)) |
- (1ULL << (CypherParser::MERGE - 55)) |
- (1ULL << (CypherParser::ON - 55)) |
- (1ULL << (CypherParser::CREATE - 55)) |
- (1ULL << (CypherParser::SET - 55)) |
- (1ULL << (CypherParser::DETACH - 55)) |
- (1ULL << (CypherParser::DELETE - 55)) |
- (1ULL << (CypherParser::REMOVE - 55)) |
- (1ULL << (CypherParser::WITH - 55)) |
- (1ULL << (CypherParser::DISTINCT - 55)) |
- (1ULL << (CypherParser::RETURN - 55)) |
- (1ULL << (CypherParser::ORDER - 55)) |
- (1ULL << (CypherParser::BY - 55)) |
- (1ULL << (CypherParser::L_SKIP - 55)) |
- (1ULL << (CypherParser::LIMIT - 55)) |
- (1ULL << (CypherParser::ASCENDING - 55)) |
- (1ULL << (CypherParser::ASC - 55)) |
- (1ULL << (CypherParser::DESCENDING - 55)) |
- (1ULL << (CypherParser::DESC - 55)) |
- (1ULL << (CypherParser::WHERE - 55)) |
- (1ULL << (CypherParser::OR - 55)) |
- (1ULL << (CypherParser::XOR - 55)) |
- (1ULL << (CypherParser::AND - 55)) |
- (1ULL << (CypherParser::NOT - 55)) |
- (1ULL << (CypherParser::IN - 55)) |
- (1ULL << (CypherParser::STARTS - 55)) |
- (1ULL << (CypherParser::ENDS - 55)) |
- (1ULL << (CypherParser::CONTAINS - 55)) |
- (1ULL << (CypherParser::IS - 55)) |
- (1ULL << (CypherParser::CYPHERNULL - 55)) |
- (1ULL << (CypherParser::COUNT - 55)) |
- (1ULL << (CypherParser::FILTER - 55)) |
- (1ULL << (CypherParser::EXTRACT - 55)) |
- (1ULL << (CypherParser::ANY - 55)) |
- (1ULL << (CypherParser::NONE - 55)) |
- (1ULL << (CypherParser::SINGLE - 55)) |
- (1ULL << (CypherParser::TRUE - 55)) |
- (1ULL << (CypherParser::FALSE - 55)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 55)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 55)))) != 0)) {
- setState(598);
- variable();
- }
- setState(602);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__8) {
- setState(601);
- match(CypherParser::T__8);
- }
- setState(605);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__10) {
- setState(604);
- relationshipTypes();
- }
- setState(608);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__4) {
- setState(607);
- rangeLiteral();
- }
- setState(611);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__27
-
- || _la == CypherParser::T__29) {
- setState(610);
- properties();
- }
- setState(613);
- match(CypherParser::T__9);
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PropertiesContext
-//------------------------------------------------------------------
-
-CypherParser::PropertiesContext::PropertiesContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::MapLiteralContext *CypherParser::PropertiesContext::mapLiteral() {
- return getRuleContext<CypherParser::MapLiteralContext>(0);
-}
-
-CypherParser::ParameterContext *CypherParser::PropertiesContext::parameter() {
- return getRuleContext<CypherParser::ParameterContext>(0);
-}
-
-size_t CypherParser::PropertiesContext::getRuleIndex() const {
- return CypherParser::RuleProperties;
-}
-
-void CypherParser::PropertiesContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterProperties(this);
-}
-
-void CypherParser::PropertiesContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitProperties(this);
-}
-
-antlrcpp::Any CypherParser::PropertiesContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitProperties(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PropertiesContext *CypherParser::properties() {
- PropertiesContext *_localctx =
- _tracker.createInstance<PropertiesContext>(_ctx, getState());
- enterRule(_localctx, 70, CypherParser::RuleProperties);
-
- auto onExit = finally([=] { exitRule(); });
- try {
- setState(617);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::T__27: {
- enterOuterAlt(_localctx, 1);
- setState(615);
- mapLiteral();
- break;
- }
-
- case CypherParser::T__29: {
- enterOuterAlt(_localctx, 2);
- setState(616);
- parameter();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RelationshipTypesContext
-//------------------------------------------------------------------
-
-CypherParser::RelationshipTypesContext::RelationshipTypesContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-std::vector<CypherParser::RelTypeNameContext *>
-CypherParser::RelationshipTypesContext::relTypeName() {
- return getRuleContexts<CypherParser::RelTypeNameContext>();
-}
-
-CypherParser::RelTypeNameContext *
-CypherParser::RelationshipTypesContext::relTypeName(size_t i) {
- return getRuleContext<CypherParser::RelTypeNameContext>(i);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::RelationshipTypesContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode *CypherParser::RelationshipTypesContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-size_t CypherParser::RelationshipTypesContext::getRuleIndex() const {
- return CypherParser::RuleRelationshipTypes;
-}
-
-void CypherParser::RelationshipTypesContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRelationshipTypes(this);
-}
-
-void CypherParser::RelationshipTypesContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRelationshipTypes(this);
-}
-
-antlrcpp::Any CypherParser::RelationshipTypesContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitRelationshipTypes(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RelationshipTypesContext *CypherParser::relationshipTypes() {
- RelationshipTypesContext *_localctx =
- _tracker.createInstance<RelationshipTypesContext>(_ctx, getState());
- enterRule(_localctx, 72, CypherParser::RuleRelationshipTypes);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(619);
- match(CypherParser::T__10);
- setState(620);
- relTypeName();
- setState(634);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__11 || _la == CypherParser::SP) {
- setState(622);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(621);
- match(CypherParser::SP);
- }
+ if (_la == CypherParser::SP) {
setState(624);
- match(CypherParser::T__11);
- setState(626);
- _errHandler->sync(this);
+ match(CypherParser::SP);
+ }
+ setState(631);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::T__10) {
- setState(625);
- match(CypherParser::T__10);
- }
+ _la = _input->LA(1);
+ if (((((_la - 53) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
+ | (1ULL << (CypherParser::UNION - 53))
+ | (1ULL << (CypherParser::ALL - 53))
+ | (1ULL << (CypherParser::OPTIONAL - 53))
+ | (1ULL << (CypherParser::MATCH - 53))
+ | (1ULL << (CypherParser::UNWIND - 53))
+ | (1ULL << (CypherParser::AS - 53))
+ | (1ULL << (CypherParser::MERGE - 53))
+ | (1ULL << (CypherParser::ON - 53))
+ | (1ULL << (CypherParser::CREATE - 53))
+ | (1ULL << (CypherParser::SET - 53))
+ | (1ULL << (CypherParser::DETACH - 53))
+ | (1ULL << (CypherParser::DELETE - 53))
+ | (1ULL << (CypherParser::REMOVE - 53))
+ | (1ULL << (CypherParser::WITH - 53))
+ | (1ULL << (CypherParser::DISTINCT - 53))
+ | (1ULL << (CypherParser::RETURN - 53))
+ | (1ULL << (CypherParser::ORDER - 53))
+ | (1ULL << (CypherParser::BY - 53))
+ | (1ULL << (CypherParser::L_SKIP - 53))
+ | (1ULL << (CypherParser::LIMIT - 53))
+ | (1ULL << (CypherParser::ASCENDING - 53))
+ | (1ULL << (CypherParser::ASC - 53))
+ | (1ULL << (CypherParser::DESCENDING - 53))
+ | (1ULL << (CypherParser::DESC - 53))
+ | (1ULL << (CypherParser::WHERE - 53))
+ | (1ULL << (CypherParser::OR - 53))
+ | (1ULL << (CypherParser::XOR - 53))
+ | (1ULL << (CypherParser::AND - 53))
+ | (1ULL << (CypherParser::NOT - 53))
+ | (1ULL << (CypherParser::IN - 53))
+ | (1ULL << (CypherParser::STARTS - 53))
+ | (1ULL << (CypherParser::ENDS - 53))
+ | (1ULL << (CypherParser::CONTAINS - 53))
+ | (1ULL << (CypherParser::IS - 53))
+ | (1ULL << (CypherParser::CYPHERNULL - 53))
+ | (1ULL << (CypherParser::COUNT - 53))
+ | (1ULL << (CypherParser::FILTER - 53))
+ | (1ULL << (CypherParser::EXTRACT - 53))
+ | (1ULL << (CypherParser::ANY - 53))
+ | (1ULL << (CypherParser::NONE - 53))
+ | (1ULL << (CypherParser::SINGLE - 53))
+ | (1ULL << (CypherParser::TRUE - 53))
+ | (1ULL << (CypherParser::FALSE - 53))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
+ setState(627);
+ variable();
setState(629);
_errHandler->sync(this);
@@ -4009,14 +3935,54 @@ CypherParser::RelationshipTypesContext *CypherParser::relationshipTypes() {
setState(628);
match(CypherParser::SP);
}
- setState(631);
- relTypeName();
- setState(636);
- _errHandler->sync(this);
- _la = _input->LA(1);
}
+ setState(637);
+ _errHandler->sync(this);
- } catch (RecognitionException &e) {
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__9) {
+ setState(633);
+ relationshipTypes();
+ setState(635);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(634);
+ match(CypherParser::SP);
+ }
+ }
+ setState(640);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__4) {
+ setState(639);
+ rangeLiteral();
+ }
+ setState(646);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__25
+
+ || _la == CypherParser::T__27) {
+ setState(642);
+ properties();
+ setState(644);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(643);
+ match(CypherParser::SP);
+ }
+ }
+ setState(648);
+ match(CypherParser::T__8);
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4025,20 +3991,214 @@ CypherParser::RelationshipTypesContext *CypherParser::relationshipTypes() {
return _localctx;
}
-//----------------- NodeLabelsContext
-//------------------------------------------------------------------
+//----------------- PropertiesContext ------------------------------------------------------------------
-CypherParser::NodeLabelsContext::NodeLabelsContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PropertiesContext::PropertiesContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::NodeLabelContext *>
-CypherParser::NodeLabelsContext::nodeLabel() {
+CypherParser::MapLiteralContext* CypherParser::PropertiesContext::mapLiteral() {
+ return getRuleContext<CypherParser::MapLiteralContext>(0);
+}
+
+CypherParser::ParameterContext* CypherParser::PropertiesContext::parameter() {
+ return getRuleContext<CypherParser::ParameterContext>(0);
+}
+
+
+size_t CypherParser::PropertiesContext::getRuleIndex() const {
+ return CypherParser::RuleProperties;
+}
+
+void CypherParser::PropertiesContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterProperties(this);
+}
+
+void CypherParser::PropertiesContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitProperties(this);
+}
+
+
+antlrcpp::Any CypherParser::PropertiesContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitProperties(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::PropertiesContext* CypherParser::properties() {
+ PropertiesContext *_localctx = _tracker.createInstance<PropertiesContext>(_ctx, getState());
+ enterRule(_localctx, 70, CypherParser::RuleProperties);
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ setState(652);
+ _errHandler->sync(this);
+ switch (_input->LA(1)) {
+ case CypherParser::T__25: {
+ enterOuterAlt(_localctx, 1);
+ setState(650);
+ mapLiteral();
+ break;
+ }
+
+ case CypherParser::T__27: {
+ enterOuterAlt(_localctx, 2);
+ setState(651);
+ parameter();
+ break;
+ }
+
+ default:
+ throw NoViableAltException(this);
+ }
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- RelationshipTypesContext ------------------------------------------------------------------
+
+CypherParser::RelationshipTypesContext::RelationshipTypesContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<CypherParser::RelTypeNameContext *> CypherParser::RelationshipTypesContext::relTypeName() {
+ return getRuleContexts<CypherParser::RelTypeNameContext>();
+}
+
+CypherParser::RelTypeNameContext* CypherParser::RelationshipTypesContext::relTypeName(size_t i) {
+ return getRuleContext<CypherParser::RelTypeNameContext>(i);
+}
+
+std::vector<tree::TerminalNode *> CypherParser::RelationshipTypesContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::RelationshipTypesContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+
+size_t CypherParser::RelationshipTypesContext::getRuleIndex() const {
+ return CypherParser::RuleRelationshipTypes;
+}
+
+void CypherParser::RelationshipTypesContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterRelationshipTypes(this);
+}
+
+void CypherParser::RelationshipTypesContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitRelationshipTypes(this);
+}
+
+
+antlrcpp::Any CypherParser::RelationshipTypesContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitRelationshipTypes(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::RelationshipTypesContext* CypherParser::relationshipTypes() {
+ RelationshipTypesContext *_localctx = _tracker.createInstance<RelationshipTypesContext>(_ctx, getState());
+ enterRule(_localctx, 72, CypherParser::RuleRelationshipTypes);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ size_t alt;
+ enterOuterAlt(_localctx, 1);
+ setState(654);
+ match(CypherParser::T__9);
+ setState(656);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(655);
+ match(CypherParser::SP);
+ }
+ setState(658);
+ relTypeName();
+ setState(672);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx);
+ while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
+ if (alt == 1) {
+ setState(660);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(659);
+ match(CypherParser::SP);
+ }
+ setState(662);
+ match(CypherParser::T__10);
+ setState(664);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__9) {
+ setState(663);
+ match(CypherParser::T__9);
+ }
+ setState(667);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(666);
+ match(CypherParser::SP);
+ }
+ setState(669);
+ relTypeName();
+ }
+ setState(674);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx);
+ }
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- NodeLabelsContext ------------------------------------------------------------------
+
+CypherParser::NodeLabelsContext::NodeLabelsContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<CypherParser::NodeLabelContext *> CypherParser::NodeLabelsContext::nodeLabel() {
return getRuleContexts<CypherParser::NodeLabelContext>();
}
-CypherParser::NodeLabelContext *CypherParser::NodeLabelsContext::nodeLabel(
- size_t i) {
+CypherParser::NodeLabelContext* CypherParser::NodeLabelsContext::nodeLabel(size_t i) {
return getRuleContext<CypherParser::NodeLabelContext>(i);
}
@@ -4046,70 +4206,71 @@ std::vector<tree::TerminalNode *> CypherParser::NodeLabelsContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::NodeLabelsContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::NodeLabelsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::NodeLabelsContext::getRuleIndex() const {
return CypherParser::RuleNodeLabels;
}
-void CypherParser::NodeLabelsContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::NodeLabelsContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterNodeLabels(this);
+ if (parserListener != nullptr)
+ parserListener->enterNodeLabels(this);
}
-void CypherParser::NodeLabelsContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::NodeLabelsContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitNodeLabels(this);
+ if (parserListener != nullptr)
+ parserListener->exitNodeLabels(this);
}
-antlrcpp::Any CypherParser::NodeLabelsContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::NodeLabelsContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitNodeLabels(this);
else
return visitor->visitChildren(this);
}
-CypherParser::NodeLabelsContext *CypherParser::nodeLabels() {
- NodeLabelsContext *_localctx =
- _tracker.createInstance<NodeLabelsContext>(_ctx, getState());
+CypherParser::NodeLabelsContext* CypherParser::nodeLabels() {
+ NodeLabelsContext *_localctx = _tracker.createInstance<NodeLabelsContext>(_ctx, getState());
enterRule(_localctx, 74, CypherParser::RuleNodeLabels);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(637);
+ setState(675);
nodeLabel();
- setState(644);
+ setState(682);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98,
- _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(639);
+ setState(677);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(638);
+ setState(676);
match(CypherParser::SP);
}
- setState(641);
- nodeLabel();
+ setState(679);
+ nodeLabel();
}
- setState(646);
+ setState(684);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 98, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4118,55 +4279,70 @@ CypherParser::NodeLabelsContext *CypherParser::nodeLabels() {
return _localctx;
}
-//----------------- NodeLabelContext
-//------------------------------------------------------------------
+//----------------- NodeLabelContext ------------------------------------------------------------------
-CypherParser::NodeLabelContext::NodeLabelContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::NodeLabelContext::NodeLabelContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::LabelNameContext *CypherParser::NodeLabelContext::labelName() {
+CypherParser::LabelNameContext* CypherParser::NodeLabelContext::labelName() {
return getRuleContext<CypherParser::LabelNameContext>(0);
}
+tree::TerminalNode* CypherParser::NodeLabelContext::SP() {
+ return getToken(CypherParser::SP, 0);
+}
+
+
size_t CypherParser::NodeLabelContext::getRuleIndex() const {
return CypherParser::RuleNodeLabel;
}
-void CypherParser::NodeLabelContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::NodeLabelContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterNodeLabel(this);
+ if (parserListener != nullptr)
+ parserListener->enterNodeLabel(this);
}
-void CypherParser::NodeLabelContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::NodeLabelContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitNodeLabel(this);
+ if (parserListener != nullptr)
+ parserListener->exitNodeLabel(this);
}
-antlrcpp::Any CypherParser::NodeLabelContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::NodeLabelContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitNodeLabel(this);
else
return visitor->visitChildren(this);
}
-CypherParser::NodeLabelContext *CypherParser::nodeLabel() {
- NodeLabelContext *_localctx =
- _tracker.createInstance<NodeLabelContext>(_ctx, getState());
+CypherParser::NodeLabelContext* CypherParser::nodeLabel() {
+ NodeLabelContext *_localctx = _tracker.createInstance<NodeLabelContext>(_ctx, getState());
enterRule(_localctx, 76, CypherParser::RuleNodeLabel);
+ size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(647);
- match(CypherParser::T__10);
- setState(648);
- labelName();
+ setState(685);
+ match(CypherParser::T__9);
+ setState(687);
+ _errHandler->sync(this);
- } catch (RecognitionException &e) {
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(686);
+ match(CypherParser::SP);
+ }
+ setState(689);
+ labelName();
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4175,130 +4351,130 @@ CypherParser::NodeLabelContext *CypherParser::nodeLabel() {
return _localctx;
}
-//----------------- RangeLiteralContext
-//------------------------------------------------------------------
+//----------------- RangeLiteralContext ------------------------------------------------------------------
-CypherParser::RangeLiteralContext::RangeLiteralContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::RangeLiteralContext::RangeLiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
std::vector<tree::TerminalNode *> CypherParser::RangeLiteralContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::RangeLiteralContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::RangeLiteralContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-std::vector<CypherParser::IntegerLiteralContext *>
-CypherParser::RangeLiteralContext::integerLiteral() {
+std::vector<CypherParser::IntegerLiteralContext *> CypherParser::RangeLiteralContext::integerLiteral() {
return getRuleContexts<CypherParser::IntegerLiteralContext>();
}
-CypherParser::IntegerLiteralContext *
-CypherParser::RangeLiteralContext::integerLiteral(size_t i) {
+CypherParser::IntegerLiteralContext* CypherParser::RangeLiteralContext::integerLiteral(size_t i) {
return getRuleContext<CypherParser::IntegerLiteralContext>(i);
}
+
size_t CypherParser::RangeLiteralContext::getRuleIndex() const {
return CypherParser::RuleRangeLiteral;
}
-void CypherParser::RangeLiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RangeLiteralContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRangeLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->enterRangeLiteral(this);
}
-void CypherParser::RangeLiteralContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RangeLiteralContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRangeLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->exitRangeLiteral(this);
}
-antlrcpp::Any CypherParser::RangeLiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RangeLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRangeLiteral(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RangeLiteralContext *CypherParser::rangeLiteral() {
- RangeLiteralContext *_localctx =
- _tracker.createInstance<RangeLiteralContext>(_ctx, getState());
+CypherParser::RangeLiteralContext* CypherParser::rangeLiteral() {
+ RangeLiteralContext *_localctx = _tracker.createInstance<RangeLiteralContext>(_ctx, getState());
enterRule(_localctx, 78, CypherParser::RuleRangeLiteral);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(650);
+ setState(691);
match(CypherParser::T__4);
- setState(652);
+ setState(693);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(651);
+ setState(692);
match(CypherParser::SP);
}
- setState(658);
+ setState(699);
_errHandler->sync(this);
_la = _input->LA(1);
- if ((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::HexInteger) |
- (1ULL << CypherParser::DecimalInteger) |
- (1ULL << CypherParser::OctalInteger))) != 0)) {
- setState(654);
+ if ((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::HexInteger)
+ | (1ULL << CypherParser::DecimalInteger)
+ | (1ULL << CypherParser::OctalInteger))) != 0)) {
+ setState(695);
integerLiteral();
- setState(656);
+ setState(697);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(655);
+ setState(696);
match(CypherParser::SP);
}
}
- setState(670);
+ setState(711);
_errHandler->sync(this);
_la = _input->LA(1);
- if (_la == CypherParser::T__12) {
- setState(660);
- match(CypherParser::T__12);
- setState(662);
+ if (_la == CypherParser::T__11) {
+ setState(701);
+ match(CypherParser::T__11);
+ setState(703);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(661);
+ setState(702);
match(CypherParser::SP);
}
- setState(668);
+ setState(709);
_errHandler->sync(this);
_la = _input->LA(1);
- if ((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::HexInteger) |
- (1ULL << CypherParser::DecimalInteger) |
- (1ULL << CypherParser::OctalInteger))) != 0)) {
- setState(664);
+ if ((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::HexInteger)
+ | (1ULL << CypherParser::DecimalInteger)
+ | (1ULL << CypherParser::OctalInteger))) != 0)) {
+ setState(705);
integerLiteral();
- setState(666);
+ setState(707);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(665);
+ setState(706);
match(CypherParser::SP);
}
}
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4307,54 +4483,55 @@ CypherParser::RangeLiteralContext *CypherParser::rangeLiteral() {
return _localctx;
}
-//----------------- LabelNameContext
-//------------------------------------------------------------------
+//----------------- LabelNameContext ------------------------------------------------------------------
-CypherParser::LabelNameContext::LabelNameContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::LabelNameContext::LabelNameContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::SymbolicNameContext *
-CypherParser::LabelNameContext::symbolicName() {
+CypherParser::SymbolicNameContext* CypherParser::LabelNameContext::symbolicName() {
return getRuleContext<CypherParser::SymbolicNameContext>(0);
}
+
size_t CypherParser::LabelNameContext::getRuleIndex() const {
return CypherParser::RuleLabelName;
}
-void CypherParser::LabelNameContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::LabelNameContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterLabelName(this);
+ if (parserListener != nullptr)
+ parserListener->enterLabelName(this);
}
-void CypherParser::LabelNameContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::LabelNameContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitLabelName(this);
+ if (parserListener != nullptr)
+ parserListener->exitLabelName(this);
}
-antlrcpp::Any CypherParser::LabelNameContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::LabelNameContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitLabelName(this);
else
return visitor->visitChildren(this);
}
-CypherParser::LabelNameContext *CypherParser::labelName() {
- LabelNameContext *_localctx =
- _tracker.createInstance<LabelNameContext>(_ctx, getState());
+CypherParser::LabelNameContext* CypherParser::labelName() {
+ LabelNameContext *_localctx = _tracker.createInstance<LabelNameContext>(_ctx, getState());
enterRule(_localctx, 80, CypherParser::RuleLabelName);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(672);
+ setState(713);
symbolicName();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4363,54 +4540,55 @@ CypherParser::LabelNameContext *CypherParser::labelName() {
return _localctx;
}
-//----------------- RelTypeNameContext
-//------------------------------------------------------------------
+//----------------- RelTypeNameContext ------------------------------------------------------------------
-CypherParser::RelTypeNameContext::RelTypeNameContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::RelTypeNameContext::RelTypeNameContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::SymbolicNameContext *
-CypherParser::RelTypeNameContext::symbolicName() {
+CypherParser::SymbolicNameContext* CypherParser::RelTypeNameContext::symbolicName() {
return getRuleContext<CypherParser::SymbolicNameContext>(0);
}
+
size_t CypherParser::RelTypeNameContext::getRuleIndex() const {
return CypherParser::RuleRelTypeName;
}
-void CypherParser::RelTypeNameContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RelTypeNameContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRelTypeName(this);
+ if (parserListener != nullptr)
+ parserListener->enterRelTypeName(this);
}
-void CypherParser::RelTypeNameContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RelTypeNameContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRelTypeName(this);
+ if (parserListener != nullptr)
+ parserListener->exitRelTypeName(this);
}
-antlrcpp::Any CypherParser::RelTypeNameContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RelTypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRelTypeName(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RelTypeNameContext *CypherParser::relTypeName() {
- RelTypeNameContext *_localctx =
- _tracker.createInstance<RelTypeNameContext>(_ctx, getState());
+CypherParser::RelTypeNameContext* CypherParser::relTypeName() {
+ RelTypeNameContext *_localctx = _tracker.createInstance<RelTypeNameContext>(_ctx, getState());
enterRule(_localctx, 82, CypherParser::RuleRelTypeName);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(674);
+ setState(715);
symbolicName();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4419,54 +4597,55 @@ CypherParser::RelTypeNameContext *CypherParser::relTypeName() {
return _localctx;
}
-//----------------- ExpressionContext
-//------------------------------------------------------------------
+//----------------- ExpressionContext ------------------------------------------------------------------
-CypherParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::Expression12Context *
-CypherParser::ExpressionContext::expression12() {
+CypherParser::Expression12Context* CypherParser::ExpressionContext::expression12() {
return getRuleContext<CypherParser::Expression12Context>(0);
}
+
size_t CypherParser::ExpressionContext::getRuleIndex() const {
return CypherParser::RuleExpression;
}
-void CypherParser::ExpressionContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ExpressionContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression(this);
}
-void CypherParser::ExpressionContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ExpressionContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression(this);
}
-antlrcpp::Any CypherParser::ExpressionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ExpressionContext *CypherParser::expression() {
- ExpressionContext *_localctx =
- _tracker.createInstance<ExpressionContext>(_ctx, getState());
+CypherParser::ExpressionContext* CypherParser::expression() {
+ ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
enterRule(_localctx, 84, CypherParser::RuleExpression);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(676);
+ setState(717);
expression12();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4475,20 +4654,17 @@ CypherParser::ExpressionContext *CypherParser::expression() {
return _localctx;
}
-//----------------- Expression12Context
-//------------------------------------------------------------------
+//----------------- Expression12Context ------------------------------------------------------------------
-CypherParser::Expression12Context::Expression12Context(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression12Context::Expression12Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::Expression11Context *>
-CypherParser::Expression12Context::expression11() {
+std::vector<CypherParser::Expression11Context *> CypherParser::Expression12Context::expression11() {
return getRuleContexts<CypherParser::Expression11Context>();
}
-CypherParser::Expression11Context *
-CypherParser::Expression12Context::expression11(size_t i) {
+CypherParser::Expression11Context* CypherParser::Expression12Context::expression11(size_t i) {
return getRuleContext<CypherParser::Expression11Context>(i);
}
@@ -4496,7 +4672,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression12Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression12Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression12Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
@@ -4504,67 +4680,68 @@ std::vector<tree::TerminalNode *> CypherParser::Expression12Context::OR() {
return getTokens(CypherParser::OR);
}
-tree::TerminalNode *CypherParser::Expression12Context::OR(size_t i) {
+tree::TerminalNode* CypherParser::Expression12Context::OR(size_t i) {
return getToken(CypherParser::OR, i);
}
+
size_t CypherParser::Expression12Context::getRuleIndex() const {
return CypherParser::RuleExpression12;
}
-void CypherParser::Expression12Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression12Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression12(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression12(this);
}
-void CypherParser::Expression12Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression12Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression12(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression12(this);
}
-antlrcpp::Any CypherParser::Expression12Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression12Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression12(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression12Context *CypherParser::expression12() {
- Expression12Context *_localctx =
- _tracker.createInstance<Expression12Context>(_ctx, getState());
+CypherParser::Expression12Context* CypherParser::expression12() {
+ Expression12Context *_localctx = _tracker.createInstance<Expression12Context>(_ctx, getState());
enterRule(_localctx, 86, CypherParser::RuleExpression12);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(678);
+ setState(719);
expression11();
- setState(685);
+ setState(726);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 106, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(679);
+ setState(720);
match(CypherParser::SP);
- setState(680);
+ setState(721);
match(CypherParser::OR);
- setState(681);
+ setState(722);
match(CypherParser::SP);
- setState(682);
- expression11();
+ setState(723);
+ expression11();
}
- setState(687);
+ setState(728);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 106, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4573,20 +4750,17 @@ CypherParser::Expression12Context *CypherParser::expression12() {
return _localctx;
}
-//----------------- Expression11Context
-//------------------------------------------------------------------
+//----------------- Expression11Context ------------------------------------------------------------------
-CypherParser::Expression11Context::Expression11Context(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression11Context::Expression11Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::Expression10Context *>
-CypherParser::Expression11Context::expression10() {
+std::vector<CypherParser::Expression10Context *> CypherParser::Expression11Context::expression10() {
return getRuleContexts<CypherParser::Expression10Context>();
}
-CypherParser::Expression10Context *
-CypherParser::Expression11Context::expression10(size_t i) {
+CypherParser::Expression10Context* CypherParser::Expression11Context::expression10(size_t i) {
return getRuleContext<CypherParser::Expression10Context>(i);
}
@@ -4594,7 +4768,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression11Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression11Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression11Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
@@ -4602,67 +4776,68 @@ std::vector<tree::TerminalNode *> CypherParser::Expression11Context::XOR() {
return getTokens(CypherParser::XOR);
}
-tree::TerminalNode *CypherParser::Expression11Context::XOR(size_t i) {
+tree::TerminalNode* CypherParser::Expression11Context::XOR(size_t i) {
return getToken(CypherParser::XOR, i);
}
+
size_t CypherParser::Expression11Context::getRuleIndex() const {
return CypherParser::RuleExpression11;
}
-void CypherParser::Expression11Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression11Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression11(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression11(this);
}
-void CypherParser::Expression11Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression11Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression11(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression11(this);
}
-antlrcpp::Any CypherParser::Expression11Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression11Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression11(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression11Context *CypherParser::expression11() {
- Expression11Context *_localctx =
- _tracker.createInstance<Expression11Context>(_ctx, getState());
+CypherParser::Expression11Context* CypherParser::expression11() {
+ Expression11Context *_localctx = _tracker.createInstance<Expression11Context>(_ctx, getState());
enterRule(_localctx, 88, CypherParser::RuleExpression11);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(688);
+ setState(729);
expression10();
- setState(695);
+ setState(736);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 107, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(689);
+ setState(730);
match(CypherParser::SP);
- setState(690);
+ setState(731);
match(CypherParser::XOR);
- setState(691);
+ setState(732);
match(CypherParser::SP);
- setState(692);
- expression10();
+ setState(733);
+ expression10();
}
- setState(697);
+ setState(738);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 107, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4671,20 +4846,17 @@ CypherParser::Expression11Context *CypherParser::expression11() {
return _localctx;
}
-//----------------- Expression10Context
-//------------------------------------------------------------------
+//----------------- Expression10Context ------------------------------------------------------------------
-CypherParser::Expression10Context::Expression10Context(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression10Context::Expression10Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::Expression9Context *>
-CypherParser::Expression10Context::expression9() {
+std::vector<CypherParser::Expression9Context *> CypherParser::Expression10Context::expression9() {
return getRuleContexts<CypherParser::Expression9Context>();
}
-CypherParser::Expression9Context *
-CypherParser::Expression10Context::expression9(size_t i) {
+CypherParser::Expression9Context* CypherParser::Expression10Context::expression9(size_t i) {
return getRuleContext<CypherParser::Expression9Context>(i);
}
@@ -4692,7 +4864,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression10Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression10Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression10Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
@@ -4700,67 +4872,68 @@ std::vector<tree::TerminalNode *> CypherParser::Expression10Context::AND() {
return getTokens(CypherParser::AND);
}
-tree::TerminalNode *CypherParser::Expression10Context::AND(size_t i) {
+tree::TerminalNode* CypherParser::Expression10Context::AND(size_t i) {
return getToken(CypherParser::AND, i);
}
+
size_t CypherParser::Expression10Context::getRuleIndex() const {
return CypherParser::RuleExpression10;
}
-void CypherParser::Expression10Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression10Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression10(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression10(this);
}
-void CypherParser::Expression10Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression10Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression10(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression10(this);
}
-antlrcpp::Any CypherParser::Expression10Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression10Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression10(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression10Context *CypherParser::expression10() {
- Expression10Context *_localctx =
- _tracker.createInstance<Expression10Context>(_ctx, getState());
+CypherParser::Expression10Context* CypherParser::expression10() {
+ Expression10Context *_localctx = _tracker.createInstance<Expression10Context>(_ctx, getState());
enterRule(_localctx, 90, CypherParser::RuleExpression10);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(698);
+ setState(739);
expression9();
- setState(705);
+ setState(746);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 108, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 121, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(699);
+ setState(740);
match(CypherParser::SP);
- setState(700);
+ setState(741);
match(CypherParser::AND);
- setState(701);
+ setState(742);
match(CypherParser::SP);
- setState(702);
- expression9();
+ setState(743);
+ expression9();
}
- setState(707);
+ setState(748);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 108, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 121, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4769,15 +4942,13 @@ CypherParser::Expression10Context *CypherParser::expression10() {
return _localctx;
}
-//----------------- Expression9Context
-//------------------------------------------------------------------
+//----------------- Expression9Context ------------------------------------------------------------------
-CypherParser::Expression9Context::Expression9Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression9Context::Expression9Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::Expression8Context *
-CypherParser::Expression9Context::expression8() {
+CypherParser::Expression8Context* CypherParser::Expression9Context::expression8() {
return getRuleContext<CypherParser::Expression8Context>(0);
}
@@ -4785,7 +4956,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression9Context::NOT() {
return getTokens(CypherParser::NOT);
}
-tree::TerminalNode *CypherParser::Expression9Context::NOT(size_t i) {
+tree::TerminalNode* CypherParser::Expression9Context::NOT(size_t i) {
return getToken(CypherParser::NOT, i);
}
@@ -4793,70 +4964,71 @@ std::vector<tree::TerminalNode *> CypherParser::Expression9Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression9Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression9Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::Expression9Context::getRuleIndex() const {
return CypherParser::RuleExpression9;
}
-void CypherParser::Expression9Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression9Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression9(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression9(this);
}
-void CypherParser::Expression9Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression9Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression9(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression9(this);
}
-antlrcpp::Any CypherParser::Expression9Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression9Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression9(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression9Context *CypherParser::expression9() {
- Expression9Context *_localctx =
- _tracker.createInstance<Expression9Context>(_ctx, getState());
+CypherParser::Expression9Context* CypherParser::expression9() {
+ Expression9Context *_localctx = _tracker.createInstance<Expression9Context>(_ctx, getState());
enterRule(_localctx, 92, CypherParser::RuleExpression9);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(714);
+ setState(755);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 110, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(708);
+ setState(749);
match(CypherParser::NOT);
- setState(710);
+ setState(751);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(709);
+ setState(750);
match(CypherParser::SP);
- }
+ }
}
- setState(716);
+ setState(757);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 110, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx);
}
- setState(717);
+ setState(758);
expression8();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4865,25 +5037,21 @@ CypherParser::Expression9Context *CypherParser::expression9() {
return _localctx;
}
-//----------------- Expression8Context
-//------------------------------------------------------------------
+//----------------- Expression8Context ------------------------------------------------------------------
-CypherParser::Expression8Context::Expression8Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression8Context::Expression8Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::Expression7Context *
-CypherParser::Expression8Context::expression7() {
+CypherParser::Expression7Context* CypherParser::Expression8Context::expression7() {
return getRuleContext<CypherParser::Expression7Context>(0);
}
-std::vector<CypherParser::PartialComparisonExpressionContext *>
-CypherParser::Expression8Context::partialComparisonExpression() {
+std::vector<CypherParser::PartialComparisonExpressionContext *> CypherParser::Expression8Context::partialComparisonExpression() {
return getRuleContexts<CypherParser::PartialComparisonExpressionContext>();
}
-CypherParser::PartialComparisonExpressionContext *
-CypherParser::Expression8Context::partialComparisonExpression(size_t i) {
+CypherParser::PartialComparisonExpressionContext* CypherParser::Expression8Context::partialComparisonExpression(size_t i) {
return getRuleContext<CypherParser::PartialComparisonExpressionContext>(i);
}
@@ -4891,70 +5059,71 @@ std::vector<tree::TerminalNode *> CypherParser::Expression8Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression8Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression8Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::Expression8Context::getRuleIndex() const {
return CypherParser::RuleExpression8;
}
-void CypherParser::Expression8Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression8Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression8(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression8(this);
}
-void CypherParser::Expression8Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression8Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression8(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression8(this);
}
-antlrcpp::Any CypherParser::Expression8Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression8Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression8(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression8Context *CypherParser::expression8() {
- Expression8Context *_localctx =
- _tracker.createInstance<Expression8Context>(_ctx, getState());
+CypherParser::Expression8Context* CypherParser::expression8() {
+ Expression8Context *_localctx = _tracker.createInstance<Expression8Context>(_ctx, getState());
enterRule(_localctx, 94, CypherParser::RuleExpression8);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(719);
+ setState(760);
expression7();
- setState(726);
+ setState(767);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 112, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(721);
+ setState(762);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(720);
+ setState(761);
match(CypherParser::SP);
}
- setState(723);
- partialComparisonExpression();
+ setState(764);
+ partialComparisonExpression();
}
- setState(728);
+ setState(769);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 112, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -4963,20 +5132,17 @@ CypherParser::Expression8Context *CypherParser::expression8() {
return _localctx;
}
-//----------------- Expression7Context
-//------------------------------------------------------------------
+//----------------- Expression7Context ------------------------------------------------------------------
-CypherParser::Expression7Context::Expression7Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression7Context::Expression7Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::Expression6Context *>
-CypherParser::Expression7Context::expression6() {
+std::vector<CypherParser::Expression6Context *> CypherParser::Expression7Context::expression6() {
return getRuleContexts<CypherParser::Expression6Context>();
}
-CypherParser::Expression6Context *CypherParser::Expression7Context::expression6(
- size_t i) {
+CypherParser::Expression6Context* CypherParser::Expression7Context::expression6(size_t i) {
return getRuleContext<CypherParser::Expression6Context>(i);
}
@@ -4984,112 +5150,113 @@ std::vector<tree::TerminalNode *> CypherParser::Expression7Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression7Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression7Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::Expression7Context::getRuleIndex() const {
return CypherParser::RuleExpression7;
}
-void CypherParser::Expression7Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression7Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression7(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression7(this);
}
-void CypherParser::Expression7Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression7Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression7(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression7(this);
}
-antlrcpp::Any CypherParser::Expression7Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression7Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression7(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression7Context *CypherParser::expression7() {
- Expression7Context *_localctx =
- _tracker.createInstance<Expression7Context>(_ctx, getState());
+CypherParser::Expression7Context* CypherParser::expression7() {
+ Expression7Context *_localctx = _tracker.createInstance<Expression7Context>(_ctx, getState());
enterRule(_localctx, 96, CypherParser::RuleExpression7);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(729);
+ setState(770);
expression6();
- setState(748);
+ setState(789);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 118, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(746);
+ setState(787);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 117, _ctx)) {
- case 1: {
- setState(731);
- _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 130, _ctx)) {
+ case 1: {
+ setState(772);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(730);
- match(CypherParser::SP);
- }
- setState(733);
- match(CypherParser::T__13);
- setState(735);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(734);
- match(CypherParser::SP);
- }
- setState(737);
- expression6();
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(771);
+ match(CypherParser::SP);
}
+ setState(774);
+ match(CypherParser::T__12);
+ setState(776);
+ _errHandler->sync(this);
- case 2: {
- setState(739);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(738);
- match(CypherParser::SP);
- }
- setState(741);
- match(CypherParser::T__14);
- setState(743);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(742);
- match(CypherParser::SP);
- }
- setState(745);
- expression6();
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(775);
+ match(CypherParser::SP);
}
+ setState(778);
+ expression6();
+ break;
}
- }
- setState(750);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 118, _ctx);
- }
- } catch (RecognitionException &e) {
+ case 2: {
+ setState(780);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(779);
+ match(CypherParser::SP);
+ }
+ setState(782);
+ match(CypherParser::T__13);
+ setState(784);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(783);
+ match(CypherParser::SP);
+ }
+ setState(786);
+ expression6();
+ break;
+ }
+
+ }
+ }
+ setState(791);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx);
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -5098,20 +5265,17 @@ CypherParser::Expression7Context *CypherParser::expression7() {
return _localctx;
}
-//----------------- Expression6Context
-//------------------------------------------------------------------
+//----------------- Expression6Context ------------------------------------------------------------------
-CypherParser::Expression6Context::Expression6Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression6Context::Expression6Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::Expression5Context *>
-CypherParser::Expression6Context::expression5() {
+std::vector<CypherParser::Expression5Context *> CypherParser::Expression6Context::expression5() {
return getRuleContexts<CypherParser::Expression5Context>();
}
-CypherParser::Expression5Context *CypherParser::Expression6Context::expression5(
- size_t i) {
+CypherParser::Expression5Context* CypherParser::Expression6Context::expression5(size_t i) {
return getRuleContext<CypherParser::Expression5Context>(i);
}
@@ -5119,136 +5283,137 @@ std::vector<tree::TerminalNode *> CypherParser::Expression6Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression6Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression6Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::Expression6Context::getRuleIndex() const {
return CypherParser::RuleExpression6;
}
-void CypherParser::Expression6Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression6Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression6(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression6(this);
}
-void CypherParser::Expression6Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression6Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression6(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression6(this);
}
-antlrcpp::Any CypherParser::Expression6Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression6Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression6(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression6Context *CypherParser::expression6() {
- Expression6Context *_localctx =
- _tracker.createInstance<Expression6Context>(_ctx, getState());
+CypherParser::Expression6Context* CypherParser::expression6() {
+ Expression6Context *_localctx = _tracker.createInstance<Expression6Context>(_ctx, getState());
enterRule(_localctx, 98, CypherParser::RuleExpression6);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(751);
+ setState(792);
expression5();
- setState(778);
+ setState(819);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 126, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(776);
+ setState(817);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 125, _ctx)) {
- case 1: {
- setState(753);
- _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx)) {
+ case 1: {
+ setState(794);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(752);
- match(CypherParser::SP);
- }
- setState(755);
- match(CypherParser::T__4);
- setState(757);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(756);
- match(CypherParser::SP);
- }
- setState(759);
- expression5();
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(793);
+ match(CypherParser::SP);
}
+ setState(796);
+ match(CypherParser::T__4);
+ setState(798);
+ _errHandler->sync(this);
- case 2: {
- setState(761);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(760);
- match(CypherParser::SP);
- }
- setState(763);
- match(CypherParser::T__15);
- setState(765);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(764);
- match(CypherParser::SP);
- }
- setState(767);
- expression5();
- break;
- }
-
- case 3: {
- setState(769);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(768);
- match(CypherParser::SP);
- }
- setState(771);
- match(CypherParser::T__16);
- setState(773);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(772);
- match(CypherParser::SP);
- }
- setState(775);
- expression5();
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(797);
+ match(CypherParser::SP);
}
+ setState(800);
+ expression5();
+ break;
}
- }
- setState(780);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 126, _ctx);
- }
- } catch (RecognitionException &e) {
+ case 2: {
+ setState(802);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(801);
+ match(CypherParser::SP);
+ }
+ setState(804);
+ match(CypherParser::T__14);
+ setState(806);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(805);
+ match(CypherParser::SP);
+ }
+ setState(808);
+ expression5();
+ break;
+ }
+
+ case 3: {
+ setState(810);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(809);
+ match(CypherParser::SP);
+ }
+ setState(812);
+ match(CypherParser::T__15);
+ setState(814);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(813);
+ match(CypherParser::SP);
+ }
+ setState(816);
+ expression5();
+ break;
+ }
+
+ }
+ }
+ setState(821);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx);
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -5257,20 +5422,17 @@ CypherParser::Expression6Context *CypherParser::expression6() {
return _localctx;
}
-//----------------- Expression5Context
-//------------------------------------------------------------------
+//----------------- Expression5Context ------------------------------------------------------------------
-CypherParser::Expression5Context::Expression5Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression5Context::Expression5Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::Expression4Context *>
-CypherParser::Expression5Context::expression4() {
+std::vector<CypherParser::Expression4Context *> CypherParser::Expression5Context::expression4() {
return getRuleContexts<CypherParser::Expression4Context>();
}
-CypherParser::Expression4Context *CypherParser::Expression5Context::expression4(
- size_t i) {
+CypherParser::Expression4Context* CypherParser::Expression5Context::expression4(size_t i) {
return getRuleContext<CypherParser::Expression4Context>(i);
}
@@ -5278,80 +5440,81 @@ std::vector<tree::TerminalNode *> CypherParser::Expression5Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression5Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression5Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::Expression5Context::getRuleIndex() const {
return CypherParser::RuleExpression5;
}
-void CypherParser::Expression5Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression5Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression5(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression5(this);
}
-void CypherParser::Expression5Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression5Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression5(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression5(this);
}
-antlrcpp::Any CypherParser::Expression5Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression5Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression5(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression5Context *CypherParser::expression5() {
- Expression5Context *_localctx =
- _tracker.createInstance<Expression5Context>(_ctx, getState());
+CypherParser::Expression5Context* CypherParser::expression5() {
+ Expression5Context *_localctx = _tracker.createInstance<Expression5Context>(_ctx, getState());
enterRule(_localctx, 100, CypherParser::RuleExpression5);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(781);
+ setState(822);
expression4();
- setState(792);
+ setState(833);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 129, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(783);
+ setState(824);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(782);
+ setState(823);
match(CypherParser::SP);
}
- setState(785);
- match(CypherParser::T__17);
- setState(787);
+ setState(826);
+ match(CypherParser::T__16);
+ setState(828);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(786);
+ setState(827);
match(CypherParser::SP);
}
- setState(789);
- expression4();
+ setState(830);
+ expression4();
}
- setState(794);
+ setState(835);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 129, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -5360,15 +5523,13 @@ CypherParser::Expression5Context *CypherParser::expression5() {
return _localctx;
}
-//----------------- Expression4Context
-//------------------------------------------------------------------
+//----------------- Expression4Context ------------------------------------------------------------------
-CypherParser::Expression4Context::Expression4Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression4Context::Expression4Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::Expression3Context *
-CypherParser::Expression4Context::expression3() {
+CypherParser::Expression3Context* CypherParser::Expression4Context::expression3() {
return getRuleContext<CypherParser::Expression3Context>(0);
}
@@ -5376,75 +5537,79 @@ std::vector<tree::TerminalNode *> CypherParser::Expression4Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression4Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression4Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::Expression4Context::getRuleIndex() const {
return CypherParser::RuleExpression4;
}
-void CypherParser::Expression4Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression4Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression4(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression4(this);
}
-void CypherParser::Expression4Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression4Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression4(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression4(this);
}
-antlrcpp::Any CypherParser::Expression4Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression4Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression4(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression4Context *CypherParser::expression4() {
- Expression4Context *_localctx =
- _tracker.createInstance<Expression4Context>(_ctx, getState());
+CypherParser::Expression4Context* CypherParser::expression4() {
+ Expression4Context *_localctx = _tracker.createInstance<Expression4Context>(_ctx, getState());
enterRule(_localctx, 102, CypherParser::RuleExpression4);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(801);
+ setState(842);
_errHandler->sync(this);
_la = _input->LA(1);
- while (_la == CypherParser::T__13
+ while (_la == CypherParser::T__12
- || _la == CypherParser::T__14) {
- setState(795);
+ || _la == CypherParser::T__13) {
+ setState(836);
_la = _input->LA(1);
- if (!(_la == CypherParser::T__13
+ if (!(_la == CypherParser::T__12
- || _la == CypherParser::T__14)) {
- _errHandler->recoverInline(this);
- } else {
+ || _la == CypherParser::T__13)) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
- setState(797);
+ setState(838);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(796);
+ setState(837);
match(CypherParser::SP);
}
- setState(803);
+ setState(844);
_errHandler->sync(this);
_la = _input->LA(1);
}
- setState(804);
+ setState(845);
expression3();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -5453,30 +5618,25 @@ CypherParser::Expression4Context *CypherParser::expression4() {
return _localctx;
}
-//----------------- Expression3Context
-//------------------------------------------------------------------
+//----------------- Expression3Context ------------------------------------------------------------------
-CypherParser::Expression3Context::Expression3Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression3Context::Expression3Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-std::vector<CypherParser::Expression2Context *>
-CypherParser::Expression3Context::expression2() {
+std::vector<CypherParser::Expression2Context *> CypherParser::Expression3Context::expression2() {
return getRuleContexts<CypherParser::Expression2Context>();
}
-CypherParser::Expression2Context *CypherParser::Expression3Context::expression2(
- size_t i) {
+CypherParser::Expression2Context* CypherParser::Expression3Context::expression2(size_t i) {
return getRuleContext<CypherParser::Expression2Context>(i);
}
-std::vector<CypherParser::ExpressionContext *>
-CypherParser::Expression3Context::expression() {
+std::vector<CypherParser::ExpressionContext *> CypherParser::Expression3Context::expression() {
return getRuleContexts<CypherParser::ExpressionContext>();
}
-CypherParser::ExpressionContext *CypherParser::Expression3Context::expression(
- size_t i) {
+CypherParser::ExpressionContext* CypherParser::Expression3Context::expression(size_t i) {
return getRuleContext<CypherParser::ExpressionContext>(i);
}
@@ -5484,7 +5644,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::Expression3Context::SP(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
@@ -5492,16 +5652,15 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::IS() {
return getTokens(CypherParser::IS);
}
-tree::TerminalNode *CypherParser::Expression3Context::IS(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::IS(size_t i) {
return getToken(CypherParser::IS, i);
}
-std::vector<tree::TerminalNode *>
-CypherParser::Expression3Context::CYPHERNULL() {
+std::vector<tree::TerminalNode *> CypherParser::Expression3Context::CYPHERNULL() {
return getTokens(CypherParser::CYPHERNULL);
}
-tree::TerminalNode *CypherParser::Expression3Context::CYPHERNULL(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::CYPHERNULL(size_t i) {
return getToken(CypherParser::CYPHERNULL, i);
}
@@ -5509,7 +5668,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::NOT() {
return getTokens(CypherParser::NOT);
}
-tree::TerminalNode *CypherParser::Expression3Context::NOT(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::NOT(size_t i) {
return getToken(CypherParser::NOT, i);
}
@@ -5517,7 +5676,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::IN() {
return getTokens(CypherParser::IN);
}
-tree::TerminalNode *CypherParser::Expression3Context::IN(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::IN(size_t i) {
return getToken(CypherParser::IN, i);
}
@@ -5525,7 +5684,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::STARTS() {
return getTokens(CypherParser::STARTS);
}
-tree::TerminalNode *CypherParser::Expression3Context::STARTS(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::STARTS(size_t i) {
return getToken(CypherParser::STARTS, i);
}
@@ -5533,7 +5692,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::WITH() {
return getTokens(CypherParser::WITH);
}
-tree::TerminalNode *CypherParser::Expression3Context::WITH(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::WITH(size_t i) {
return getToken(CypherParser::WITH, i);
}
@@ -5541,7 +5700,7 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::ENDS() {
return getTokens(CypherParser::ENDS);
}
-tree::TerminalNode *CypherParser::Expression3Context::ENDS(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::ENDS(size_t i) {
return getToken(CypherParser::ENDS, i);
}
@@ -5549,336 +5708,333 @@ std::vector<tree::TerminalNode *> CypherParser::Expression3Context::CONTAINS() {
return getTokens(CypherParser::CONTAINS);
}
-tree::TerminalNode *CypherParser::Expression3Context::CONTAINS(size_t i) {
+tree::TerminalNode* CypherParser::Expression3Context::CONTAINS(size_t i) {
return getToken(CypherParser::CONTAINS, i);
}
+
size_t CypherParser::Expression3Context::getRuleIndex() const {
return CypherParser::RuleExpression3;
}
-void CypherParser::Expression3Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression3Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression3(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression3(this);
}
-void CypherParser::Expression3Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression3Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression3(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression3(this);
}
-antlrcpp::Any CypherParser::Expression3Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression3Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression3(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression3Context *CypherParser::expression3() {
- Expression3Context *_localctx =
- _tracker.createInstance<Expression3Context>(_ctx, getState());
+CypherParser::Expression3Context* CypherParser::expression3() {
+ Expression3Context *_localctx = _tracker.createInstance<Expression3Context>(_ctx, getState());
enterRule(_localctx, 104, CypherParser::RuleExpression3);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(806);
+ setState(847);
expression2();
- setState(860);
+ setState(901);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 140, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(858);
+ setState(899);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 139, _ctx)) {
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 152, _ctx)) {
+ case 1: {
+ setState(849);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(848);
+ match(CypherParser::SP);
+ }
+ setState(851);
+ match(CypherParser::T__7);
+ setState(852);
+ expression();
+ setState(853);
+ match(CypherParser::T__8);
+ break;
+ }
+
+ case 2: {
+ setState(856);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(855);
+ match(CypherParser::SP);
+ }
+ setState(858);
+ match(CypherParser::T__7);
+ setState(860);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if ((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::T__5)
+ | (1ULL << CypherParser::T__7)
+ | (1ULL << CypherParser::T__12)
+ | (1ULL << CypherParser::T__13)
+ | (1ULL << CypherParser::T__25)
+ | (1ULL << CypherParser::T__27)
+ | (1ULL << CypherParser::StringLiteral)
+ | (1ULL << CypherParser::HexInteger)
+ | (1ULL << CypherParser::DecimalInteger)
+ | (1ULL << CypherParser::OctalInteger)
+ | (1ULL << CypherParser::HexLetter)
+ | (1ULL << CypherParser::ExponentDecimalReal)
+ | (1ULL << CypherParser::RegularDecimalReal)
+ | (1ULL << CypherParser::UNION)
+ | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
+ | (1ULL << (CypherParser::MATCH - 64))
+ | (1ULL << (CypherParser::UNWIND - 64))
+ | (1ULL << (CypherParser::AS - 64))
+ | (1ULL << (CypherParser::MERGE - 64))
+ | (1ULL << (CypherParser::ON - 64))
+ | (1ULL << (CypherParser::CREATE - 64))
+ | (1ULL << (CypherParser::SET - 64))
+ | (1ULL << (CypherParser::DETACH - 64))
+ | (1ULL << (CypherParser::DELETE - 64))
+ | (1ULL << (CypherParser::REMOVE - 64))
+ | (1ULL << (CypherParser::WITH - 64))
+ | (1ULL << (CypherParser::DISTINCT - 64))
+ | (1ULL << (CypherParser::RETURN - 64))
+ | (1ULL << (CypherParser::ORDER - 64))
+ | (1ULL << (CypherParser::BY - 64))
+ | (1ULL << (CypherParser::L_SKIP - 64))
+ | (1ULL << (CypherParser::LIMIT - 64))
+ | (1ULL << (CypherParser::ASCENDING - 64))
+ | (1ULL << (CypherParser::ASC - 64))
+ | (1ULL << (CypherParser::DESCENDING - 64))
+ | (1ULL << (CypherParser::DESC - 64))
+ | (1ULL << (CypherParser::WHERE - 64))
+ | (1ULL << (CypherParser::OR - 64))
+ | (1ULL << (CypherParser::XOR - 64))
+ | (1ULL << (CypherParser::AND - 64))
+ | (1ULL << (CypherParser::NOT - 64))
+ | (1ULL << (CypherParser::IN - 64))
+ | (1ULL << (CypherParser::STARTS - 64))
+ | (1ULL << (CypherParser::ENDS - 64))
+ | (1ULL << (CypherParser::CONTAINS - 64))
+ | (1ULL << (CypherParser::IS - 64))
+ | (1ULL << (CypherParser::CYPHERNULL - 64))
+ | (1ULL << (CypherParser::COUNT - 64))
+ | (1ULL << (CypherParser::FILTER - 64))
+ | (1ULL << (CypherParser::EXTRACT - 64))
+ | (1ULL << (CypherParser::ANY - 64))
+ | (1ULL << (CypherParser::NONE - 64))
+ | (1ULL << (CypherParser::SINGLE - 64))
+ | (1ULL << (CypherParser::TRUE - 64))
+ | (1ULL << (CypherParser::FALSE - 64))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
+ setState(859);
+ expression();
+ }
+ setState(862);
+ match(CypherParser::T__11);
+ setState(864);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if ((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::T__5)
+ | (1ULL << CypherParser::T__7)
+ | (1ULL << CypherParser::T__12)
+ | (1ULL << CypherParser::T__13)
+ | (1ULL << CypherParser::T__25)
+ | (1ULL << CypherParser::T__27)
+ | (1ULL << CypherParser::StringLiteral)
+ | (1ULL << CypherParser::HexInteger)
+ | (1ULL << CypherParser::DecimalInteger)
+ | (1ULL << CypherParser::OctalInteger)
+ | (1ULL << CypherParser::HexLetter)
+ | (1ULL << CypherParser::ExponentDecimalReal)
+ | (1ULL << CypherParser::RegularDecimalReal)
+ | (1ULL << CypherParser::UNION)
+ | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
+ | (1ULL << (CypherParser::MATCH - 64))
+ | (1ULL << (CypherParser::UNWIND - 64))
+ | (1ULL << (CypherParser::AS - 64))
+ | (1ULL << (CypherParser::MERGE - 64))
+ | (1ULL << (CypherParser::ON - 64))
+ | (1ULL << (CypherParser::CREATE - 64))
+ | (1ULL << (CypherParser::SET - 64))
+ | (1ULL << (CypherParser::DETACH - 64))
+ | (1ULL << (CypherParser::DELETE - 64))
+ | (1ULL << (CypherParser::REMOVE - 64))
+ | (1ULL << (CypherParser::WITH - 64))
+ | (1ULL << (CypherParser::DISTINCT - 64))
+ | (1ULL << (CypherParser::RETURN - 64))
+ | (1ULL << (CypherParser::ORDER - 64))
+ | (1ULL << (CypherParser::BY - 64))
+ | (1ULL << (CypherParser::L_SKIP - 64))
+ | (1ULL << (CypherParser::LIMIT - 64))
+ | (1ULL << (CypherParser::ASCENDING - 64))
+ | (1ULL << (CypherParser::ASC - 64))
+ | (1ULL << (CypherParser::DESCENDING - 64))
+ | (1ULL << (CypherParser::DESC - 64))
+ | (1ULL << (CypherParser::WHERE - 64))
+ | (1ULL << (CypherParser::OR - 64))
+ | (1ULL << (CypherParser::XOR - 64))
+ | (1ULL << (CypherParser::AND - 64))
+ | (1ULL << (CypherParser::NOT - 64))
+ | (1ULL << (CypherParser::IN - 64))
+ | (1ULL << (CypherParser::STARTS - 64))
+ | (1ULL << (CypherParser::ENDS - 64))
+ | (1ULL << (CypherParser::CONTAINS - 64))
+ | (1ULL << (CypherParser::IS - 64))
+ | (1ULL << (CypherParser::CYPHERNULL - 64))
+ | (1ULL << (CypherParser::COUNT - 64))
+ | (1ULL << (CypherParser::FILTER - 64))
+ | (1ULL << (CypherParser::EXTRACT - 64))
+ | (1ULL << (CypherParser::ANY - 64))
+ | (1ULL << (CypherParser::NONE - 64))
+ | (1ULL << (CypherParser::SINGLE - 64))
+ | (1ULL << (CypherParser::TRUE - 64))
+ | (1ULL << (CypherParser::FALSE - 64))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
+ setState(863);
+ expression();
+ }
+ setState(866);
+ match(CypherParser::T__8);
+ break;
+ }
+
+ case 3: {
+ setState(883);
+ _errHandler->sync(this);
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 150, _ctx)) {
case 1: {
- setState(808);
+ setState(868);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(807);
+ setState(867);
match(CypherParser::SP);
}
- setState(810);
- match(CypherParser::T__7);
- setState(811);
- expression();
- setState(812);
- match(CypherParser::T__9);
+ setState(870);
+ match(CypherParser::T__17);
break;
}
case 2: {
- setState(815);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(814);
- match(CypherParser::SP);
- }
- setState(817);
- match(CypherParser::T__7);
- setState(819);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) &
- ((1ULL << CypherParser::T__5) | (1ULL << CypherParser::T__7) |
- (1ULL << CypherParser::T__13) |
- (1ULL << CypherParser::T__14) |
- (1ULL << CypherParser::T__27) |
- (1ULL << CypherParser::T__29) |
- (1ULL << CypherParser::StringLiteral) |
- (1ULL << CypherParser::HexInteger) |
- (1ULL << CypherParser::DecimalInteger) |
- (1ULL << CypherParser::OctalInteger) |
- (1ULL << CypherParser::HexLetter) |
- (1ULL << CypherParser::ExponentDecimalReal) |
- (1ULL << CypherParser::RegularDecimalReal))) != 0) ||
- ((((_la - 64) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) &
- ((1ULL << (CypherParser::UNION - 64)) |
- (1ULL << (CypherParser::ALL - 64)) |
- (1ULL << (CypherParser::OPTIONAL - 64)) |
- (1ULL << (CypherParser::MATCH - 64)) |
- (1ULL << (CypherParser::UNWIND - 64)) |
- (1ULL << (CypherParser::AS - 64)) |
- (1ULL << (CypherParser::MERGE - 64)) |
- (1ULL << (CypherParser::ON - 64)) |
- (1ULL << (CypherParser::CREATE - 64)) |
- (1ULL << (CypherParser::SET - 64)) |
- (1ULL << (CypherParser::DETACH - 64)) |
- (1ULL << (CypherParser::DELETE - 64)) |
- (1ULL << (CypherParser::REMOVE - 64)) |
- (1ULL << (CypherParser::WITH - 64)) |
- (1ULL << (CypherParser::DISTINCT - 64)) |
- (1ULL << (CypherParser::RETURN - 64)) |
- (1ULL << (CypherParser::ORDER - 64)) |
- (1ULL << (CypherParser::BY - 64)) |
- (1ULL << (CypherParser::L_SKIP - 64)) |
- (1ULL << (CypherParser::LIMIT - 64)) |
- (1ULL << (CypherParser::ASCENDING - 64)) |
- (1ULL << (CypherParser::ASC - 64)) |
- (1ULL << (CypherParser::DESCENDING - 64)) |
- (1ULL << (CypherParser::DESC - 64)) |
- (1ULL << (CypherParser::WHERE - 64)) |
- (1ULL << (CypherParser::OR - 64)) |
- (1ULL << (CypherParser::XOR - 64)) |
- (1ULL << (CypherParser::AND - 64)) |
- (1ULL << (CypherParser::NOT - 64)) |
- (1ULL << (CypherParser::IN - 64)) |
- (1ULL << (CypherParser::STARTS - 64)) |
- (1ULL << (CypherParser::ENDS - 64)) |
- (1ULL << (CypherParser::CONTAINS - 64)) |
- (1ULL << (CypherParser::IS - 64)) |
- (1ULL << (CypherParser::CYPHERNULL - 64)) |
- (1ULL << (CypherParser::COUNT - 64)) |
- (1ULL << (CypherParser::FILTER - 64)) |
- (1ULL << (CypherParser::EXTRACT - 64)) |
- (1ULL << (CypherParser::ANY - 64)) |
- (1ULL << (CypherParser::NONE - 64)) |
- (1ULL << (CypherParser::SINGLE - 64)) |
- (1ULL << (CypherParser::TRUE - 64)) |
- (1ULL << (CypherParser::FALSE - 64)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 64)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(818);
- expression();
- }
- setState(821);
- match(CypherParser::T__12);
- setState(823);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) &
- ((1ULL << CypherParser::T__5) | (1ULL << CypherParser::T__7) |
- (1ULL << CypherParser::T__13) |
- (1ULL << CypherParser::T__14) |
- (1ULL << CypherParser::T__27) |
- (1ULL << CypherParser::T__29) |
- (1ULL << CypherParser::StringLiteral) |
- (1ULL << CypherParser::HexInteger) |
- (1ULL << CypherParser::DecimalInteger) |
- (1ULL << CypherParser::OctalInteger) |
- (1ULL << CypherParser::HexLetter) |
- (1ULL << CypherParser::ExponentDecimalReal) |
- (1ULL << CypherParser::RegularDecimalReal))) != 0) ||
- ((((_la - 64) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) &
- ((1ULL << (CypherParser::UNION - 64)) |
- (1ULL << (CypherParser::ALL - 64)) |
- (1ULL << (CypherParser::OPTIONAL - 64)) |
- (1ULL << (CypherParser::MATCH - 64)) |
- (1ULL << (CypherParser::UNWIND - 64)) |
- (1ULL << (CypherParser::AS - 64)) |
- (1ULL << (CypherParser::MERGE - 64)) |
- (1ULL << (CypherParser::ON - 64)) |
- (1ULL << (CypherParser::CREATE - 64)) |
- (1ULL << (CypherParser::SET - 64)) |
- (1ULL << (CypherParser::DETACH - 64)) |
- (1ULL << (CypherParser::DELETE - 64)) |
- (1ULL << (CypherParser::REMOVE - 64)) |
- (1ULL << (CypherParser::WITH - 64)) |
- (1ULL << (CypherParser::DISTINCT - 64)) |
- (1ULL << (CypherParser::RETURN - 64)) |
- (1ULL << (CypherParser::ORDER - 64)) |
- (1ULL << (CypherParser::BY - 64)) |
- (1ULL << (CypherParser::L_SKIP - 64)) |
- (1ULL << (CypherParser::LIMIT - 64)) |
- (1ULL << (CypherParser::ASCENDING - 64)) |
- (1ULL << (CypherParser::ASC - 64)) |
- (1ULL << (CypherParser::DESCENDING - 64)) |
- (1ULL << (CypherParser::DESC - 64)) |
- (1ULL << (CypherParser::WHERE - 64)) |
- (1ULL << (CypherParser::OR - 64)) |
- (1ULL << (CypherParser::XOR - 64)) |
- (1ULL << (CypherParser::AND - 64)) |
- (1ULL << (CypherParser::NOT - 64)) |
- (1ULL << (CypherParser::IN - 64)) |
- (1ULL << (CypherParser::STARTS - 64)) |
- (1ULL << (CypherParser::ENDS - 64)) |
- (1ULL << (CypherParser::CONTAINS - 64)) |
- (1ULL << (CypherParser::IS - 64)) |
- (1ULL << (CypherParser::CYPHERNULL - 64)) |
- (1ULL << (CypherParser::COUNT - 64)) |
- (1ULL << (CypherParser::FILTER - 64)) |
- (1ULL << (CypherParser::EXTRACT - 64)) |
- (1ULL << (CypherParser::ANY - 64)) |
- (1ULL << (CypherParser::NONE - 64)) |
- (1ULL << (CypherParser::SINGLE - 64)) |
- (1ULL << (CypherParser::TRUE - 64)) |
- (1ULL << (CypherParser::FALSE - 64)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 64)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(822);
- expression();
- }
- setState(825);
- match(CypherParser::T__9);
+ setState(871);
+ match(CypherParser::SP);
+ setState(872);
+ match(CypherParser::IN);
break;
}
case 3: {
- setState(842);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 137, _ctx)) {
- case 1: {
- setState(827);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(826);
- match(CypherParser::SP);
- }
- setState(829);
- match(CypherParser::T__18);
- break;
- }
-
- case 2: {
- setState(830);
- match(CypherParser::SP);
- setState(831);
- match(CypherParser::IN);
- break;
- }
-
- case 3: {
- setState(832);
- match(CypherParser::SP);
- setState(833);
- match(CypherParser::STARTS);
- setState(834);
- match(CypherParser::SP);
- setState(835);
- match(CypherParser::WITH);
- break;
- }
-
- case 4: {
- setState(836);
- match(CypherParser::SP);
- setState(837);
- match(CypherParser::ENDS);
- setState(838);
- match(CypherParser::SP);
- setState(839);
- match(CypherParser::WITH);
- break;
- }
-
- case 5: {
- setState(840);
- match(CypherParser::SP);
- setState(841);
- match(CypherParser::CONTAINS);
- break;
- }
- }
- setState(845);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(844);
- match(CypherParser::SP);
- }
- setState(847);
- expression2();
+ setState(873);
+ match(CypherParser::SP);
+ setState(874);
+ match(CypherParser::STARTS);
+ setState(875);
+ match(CypherParser::SP);
+ setState(876);
+ match(CypherParser::WITH);
break;
}
case 4: {
- setState(848);
+ setState(877);
match(CypherParser::SP);
- setState(849);
- match(CypherParser::IS);
- setState(850);
+ setState(878);
+ match(CypherParser::ENDS);
+ setState(879);
match(CypherParser::SP);
- setState(851);
- match(CypherParser::CYPHERNULL);
+ setState(880);
+ match(CypherParser::WITH);
break;
}
case 5: {
- setState(852);
+ setState(881);
match(CypherParser::SP);
- setState(853);
- match(CypherParser::IS);
- setState(854);
- match(CypherParser::SP);
- setState(855);
- match(CypherParser::NOT);
- setState(856);
- match(CypherParser::SP);
- setState(857);
- match(CypherParser::CYPHERNULL);
+ setState(882);
+ match(CypherParser::CONTAINS);
break;
}
- }
- }
- setState(862);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 140, _ctx);
- }
- } catch (RecognitionException &e) {
+ }
+ setState(886);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(885);
+ match(CypherParser::SP);
+ }
+ setState(888);
+ expression2();
+ break;
+ }
+
+ case 4: {
+ setState(889);
+ match(CypherParser::SP);
+ setState(890);
+ match(CypherParser::IS);
+ setState(891);
+ match(CypherParser::SP);
+ setState(892);
+ match(CypherParser::CYPHERNULL);
+ break;
+ }
+
+ case 5: {
+ setState(893);
+ match(CypherParser::SP);
+ setState(894);
+ match(CypherParser::IS);
+ setState(895);
+ match(CypherParser::SP);
+ setState(896);
+ match(CypherParser::NOT);
+ setState(897);
+ match(CypherParser::SP);
+ setState(898);
+ match(CypherParser::CYPHERNULL);
+ break;
+ }
+
+ }
+ }
+ setState(903);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx);
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -5887,105 +6043,117 @@ CypherParser::Expression3Context *CypherParser::expression3() {
return _localctx;
}
-//----------------- Expression2Context
-//------------------------------------------------------------------
+//----------------- Expression2Context ------------------------------------------------------------------
-CypherParser::Expression2Context::Expression2Context(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::Expression2Context::Expression2Context(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::AtomContext *CypherParser::Expression2Context::atom() {
+CypherParser::AtomContext* CypherParser::Expression2Context::atom() {
return getRuleContext<CypherParser::AtomContext>(0);
}
-std::vector<CypherParser::PropertyLookupContext *>
-CypherParser::Expression2Context::propertyLookup() {
+std::vector<CypherParser::PropertyLookupContext *> CypherParser::Expression2Context::propertyLookup() {
return getRuleContexts<CypherParser::PropertyLookupContext>();
}
-CypherParser::PropertyLookupContext *
-CypherParser::Expression2Context::propertyLookup(size_t i) {
+CypherParser::PropertyLookupContext* CypherParser::Expression2Context::propertyLookup(size_t i) {
return getRuleContext<CypherParser::PropertyLookupContext>(i);
}
-std::vector<CypherParser::NodeLabelsContext *>
-CypherParser::Expression2Context::nodeLabels() {
+std::vector<CypherParser::NodeLabelsContext *> CypherParser::Expression2Context::nodeLabels() {
return getRuleContexts<CypherParser::NodeLabelsContext>();
}
-CypherParser::NodeLabelsContext *CypherParser::Expression2Context::nodeLabels(
- size_t i) {
+CypherParser::NodeLabelsContext* CypherParser::Expression2Context::nodeLabels(size_t i) {
return getRuleContext<CypherParser::NodeLabelsContext>(i);
}
+std::vector<tree::TerminalNode *> CypherParser::Expression2Context::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::Expression2Context::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+
size_t CypherParser::Expression2Context::getRuleIndex() const {
return CypherParser::RuleExpression2;
}
-void CypherParser::Expression2Context::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression2Context::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterExpression2(this);
+ if (parserListener != nullptr)
+ parserListener->enterExpression2(this);
}
-void CypherParser::Expression2Context::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::Expression2Context::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitExpression2(this);
+ if (parserListener != nullptr)
+ parserListener->exitExpression2(this);
}
-antlrcpp::Any CypherParser::Expression2Context::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::Expression2Context::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitExpression2(this);
else
return visitor->visitChildren(this);
}
-CypherParser::Expression2Context *CypherParser::expression2() {
- Expression2Context *_localctx =
- _tracker.createInstance<Expression2Context>(_ctx, getState());
+CypherParser::Expression2Context* CypherParser::expression2() {
+ Expression2Context *_localctx = _tracker.createInstance<Expression2Context>(_ctx, getState());
enterRule(_localctx, 106, CypherParser::RuleExpression2);
+ size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(863);
+ setState(904);
atom();
- setState(868);
+ setState(914);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input,
- 142, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
- setState(866);
+ setState(906);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(905);
+ match(CypherParser::SP);
+ }
+ setState(910);
_errHandler->sync(this);
switch (_input->LA(1)) {
- case CypherParser::T__25:
- case CypherParser::SP: {
- setState(864);
+ case CypherParser::T__24: {
+ setState(908);
propertyLookup();
break;
}
- case CypherParser::T__10: {
- setState(865);
+ case CypherParser::T__9: {
+ setState(909);
nodeLabels();
break;
}
- default:
- throw NoViableAltException(this);
- }
+ default:
+ throw NoViableAltException(this);
+ }
}
- setState(870);
+ setState(916);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 142, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -5994,22 +6162,21 @@ CypherParser::Expression2Context *CypherParser::expression2() {
return _localctx;
}
-//----------------- AtomContext
-//------------------------------------------------------------------
+//----------------- AtomContext ------------------------------------------------------------------
-CypherParser::AtomContext::AtomContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::AtomContext::AtomContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::LiteralContext *CypherParser::AtomContext::literal() {
+CypherParser::LiteralContext* CypherParser::AtomContext::literal() {
return getRuleContext<CypherParser::LiteralContext>(0);
}
-CypherParser::ParameterContext *CypherParser::AtomContext::parameter() {
+CypherParser::ParameterContext* CypherParser::AtomContext::parameter() {
return getRuleContext<CypherParser::ParameterContext>(0);
}
-tree::TerminalNode *CypherParser::AtomContext::COUNT() {
+tree::TerminalNode* CypherParser::AtomContext::COUNT() {
return getToken(CypherParser::COUNT, 0);
}
@@ -6017,432 +6184,443 @@ std::vector<tree::TerminalNode *> CypherParser::AtomContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::AtomContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::AtomContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-CypherParser::ListComprehensionContext *
-CypherParser::AtomContext::listComprehension() {
+CypherParser::ListComprehensionContext* CypherParser::AtomContext::listComprehension() {
return getRuleContext<CypherParser::ListComprehensionContext>(0);
}
-tree::TerminalNode *CypherParser::AtomContext::FILTER() {
+CypherParser::PatternComprehensionContext* CypherParser::AtomContext::patternComprehension() {
+ return getRuleContext<CypherParser::PatternComprehensionContext>(0);
+}
+
+tree::TerminalNode* CypherParser::AtomContext::FILTER() {
return getToken(CypherParser::FILTER, 0);
}
-CypherParser::FilterExpressionContext *
-CypherParser::AtomContext::filterExpression() {
+CypherParser::FilterExpressionContext* CypherParser::AtomContext::filterExpression() {
return getRuleContext<CypherParser::FilterExpressionContext>(0);
}
-tree::TerminalNode *CypherParser::AtomContext::EXTRACT() {
+tree::TerminalNode* CypherParser::AtomContext::EXTRACT() {
return getToken(CypherParser::EXTRACT, 0);
}
-CypherParser::ExpressionContext *CypherParser::AtomContext::expression() {
+CypherParser::ExpressionContext* CypherParser::AtomContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
-tree::TerminalNode *CypherParser::AtomContext::ALL() {
+tree::TerminalNode* CypherParser::AtomContext::ALL() {
return getToken(CypherParser::ALL, 0);
}
-tree::TerminalNode *CypherParser::AtomContext::ANY() {
+tree::TerminalNode* CypherParser::AtomContext::ANY() {
return getToken(CypherParser::ANY, 0);
}
-tree::TerminalNode *CypherParser::AtomContext::NONE() {
+tree::TerminalNode* CypherParser::AtomContext::NONE() {
return getToken(CypherParser::NONE, 0);
}
-tree::TerminalNode *CypherParser::AtomContext::SINGLE() {
+tree::TerminalNode* CypherParser::AtomContext::SINGLE() {
return getToken(CypherParser::SINGLE, 0);
}
-CypherParser::RelationshipsPatternContext *
-CypherParser::AtomContext::relationshipsPattern() {
+CypherParser::RelationshipsPatternContext* CypherParser::AtomContext::relationshipsPattern() {
return getRuleContext<CypherParser::RelationshipsPatternContext>(0);
}
-CypherParser::ParenthesizedExpressionContext *
-CypherParser::AtomContext::parenthesizedExpression() {
+CypherParser::ParenthesizedExpressionContext* CypherParser::AtomContext::parenthesizedExpression() {
return getRuleContext<CypherParser::ParenthesizedExpressionContext>(0);
}
-CypherParser::FunctionInvocationContext *
-CypherParser::AtomContext::functionInvocation() {
+CypherParser::FunctionInvocationContext* CypherParser::AtomContext::functionInvocation() {
return getRuleContext<CypherParser::FunctionInvocationContext>(0);
}
-CypherParser::VariableContext *CypherParser::AtomContext::variable() {
+CypherParser::VariableContext* CypherParser::AtomContext::variable() {
return getRuleContext<CypherParser::VariableContext>(0);
}
+
size_t CypherParser::AtomContext::getRuleIndex() const {
return CypherParser::RuleAtom;
}
void CypherParser::AtomContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterAtom(this);
+ if (parserListener != nullptr)
+ parserListener->enterAtom(this);
}
void CypherParser::AtomContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitAtom(this);
+ if (parserListener != nullptr)
+ parserListener->exitAtom(this);
}
-antlrcpp::Any CypherParser::AtomContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::AtomContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitAtom(this);
else
return visitor->visitChildren(this);
}
-CypherParser::AtomContext *CypherParser::atom() {
- AtomContext *_localctx =
- _tracker.createInstance<AtomContext>(_ctx, getState());
+CypherParser::AtomContext* CypherParser::atom() {
+ AtomContext *_localctx = _tracker.createInstance<AtomContext>(_ctx, getState());
enterRule(_localctx, 108, CypherParser::RuleAtom);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(982);
+ setState(1029);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 166, _ctx)) {
- case 1: {
- enterOuterAlt(_localctx, 1);
- setState(871);
- literal();
- break;
- }
-
- case 2: {
- enterOuterAlt(_localctx, 2);
- setState(872);
- parameter();
- break;
- }
-
- case 3: {
- enterOuterAlt(_localctx, 3);
- setState(873);
- match(CypherParser::COUNT);
- setState(875);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(874);
- match(CypherParser::SP);
- }
- setState(877);
- match(CypherParser::T__5);
- setState(879);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(878);
- match(CypherParser::SP);
- }
- setState(881);
- match(CypherParser::T__4);
- setState(883);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(882);
- match(CypherParser::SP);
- }
- setState(885);
- match(CypherParser::T__6);
- break;
- }
-
- case 4: {
- enterOuterAlt(_localctx, 4);
- setState(886);
- listComprehension();
- break;
- }
-
- case 5: {
- enterOuterAlt(_localctx, 5);
- setState(887);
- match(CypherParser::FILTER);
- setState(889);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(888);
- match(CypherParser::SP);
- }
- setState(891);
- match(CypherParser::T__5);
- setState(893);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(892);
- match(CypherParser::SP);
- }
- setState(895);
- filterExpression();
- setState(897);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(896);
- match(CypherParser::SP);
- }
- setState(899);
- match(CypherParser::T__6);
- break;
- }
-
- case 6: {
- enterOuterAlt(_localctx, 6);
- setState(901);
- match(CypherParser::EXTRACT);
- setState(903);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(902);
- match(CypherParser::SP);
- }
- setState(905);
- match(CypherParser::T__5);
- setState(907);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(906);
- match(CypherParser::SP);
- }
- setState(909);
- filterExpression();
- setState(911);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 151, _ctx)) {
- case 1: {
- setState(910);
- match(CypherParser::SP);
- break;
- }
- }
- setState(918);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::T__11 || _la == CypherParser::SP) {
- setState(914);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(913);
- match(CypherParser::SP);
- }
- setState(916);
- match(CypherParser::T__11);
- setState(917);
- expression();
- }
- setState(920);
- match(CypherParser::T__6);
- break;
- }
-
- case 7: {
- enterOuterAlt(_localctx, 7);
- setState(922);
- match(CypherParser::ALL);
- setState(924);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(923);
- match(CypherParser::SP);
- }
- setState(926);
- match(CypherParser::T__5);
- setState(928);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(927);
- match(CypherParser::SP);
- }
- setState(930);
- filterExpression();
- setState(932);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(931);
- match(CypherParser::SP);
- }
- setState(934);
- match(CypherParser::T__6);
- break;
- }
-
- case 8: {
- enterOuterAlt(_localctx, 8);
- setState(936);
- match(CypherParser::ANY);
- setState(938);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(937);
- match(CypherParser::SP);
- }
- setState(940);
- match(CypherParser::T__5);
- setState(942);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(941);
- match(CypherParser::SP);
- }
- setState(944);
- filterExpression();
- setState(946);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(945);
- match(CypherParser::SP);
- }
- setState(948);
- match(CypherParser::T__6);
- break;
- }
-
- case 9: {
- enterOuterAlt(_localctx, 9);
- setState(950);
- match(CypherParser::NONE);
- setState(952);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(951);
- match(CypherParser::SP);
- }
- setState(954);
- match(CypherParser::T__5);
- setState(956);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(955);
- match(CypherParser::SP);
- }
- setState(958);
- filterExpression();
- setState(960);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(959);
- match(CypherParser::SP);
- }
- setState(962);
- match(CypherParser::T__6);
- break;
- }
-
- case 10: {
- enterOuterAlt(_localctx, 10);
- setState(964);
- match(CypherParser::SINGLE);
- setState(966);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(965);
- match(CypherParser::SP);
- }
- setState(968);
- match(CypherParser::T__5);
- setState(970);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(969);
- match(CypherParser::SP);
- }
- setState(972);
- filterExpression();
- setState(974);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(973);
- match(CypherParser::SP);
- }
- setState(976);
- match(CypherParser::T__6);
- break;
- }
-
- case 11: {
- enterOuterAlt(_localctx, 11);
- setState(978);
- relationshipsPattern();
- break;
- }
-
- case 12: {
- enterOuterAlt(_localctx, 12);
- setState(979);
- parenthesizedExpression();
- break;
- }
-
- case 13: {
- enterOuterAlt(_localctx, 13);
- setState(980);
- functionInvocation();
- break;
- }
-
- case 14: {
- enterOuterAlt(_localctx, 14);
- setState(981);
- variable();
- break;
- }
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 180, _ctx)) {
+ case 1: {
+ enterOuterAlt(_localctx, 1);
+ setState(917);
+ literal();
+ break;
}
- } catch (RecognitionException &e) {
+ case 2: {
+ enterOuterAlt(_localctx, 2);
+ setState(918);
+ parameter();
+ break;
+ }
+
+ case 3: {
+ enterOuterAlt(_localctx, 3);
+ setState(919);
+ match(CypherParser::COUNT);
+ setState(921);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(920);
+ match(CypherParser::SP);
+ }
+ setState(923);
+ match(CypherParser::T__5);
+ setState(925);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(924);
+ match(CypherParser::SP);
+ }
+ setState(927);
+ match(CypherParser::T__4);
+ setState(929);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(928);
+ match(CypherParser::SP);
+ }
+ setState(931);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ case 4: {
+ enterOuterAlt(_localctx, 4);
+ setState(932);
+ listComprehension();
+ break;
+ }
+
+ case 5: {
+ enterOuterAlt(_localctx, 5);
+ setState(933);
+ patternComprehension();
+ break;
+ }
+
+ case 6: {
+ enterOuterAlt(_localctx, 6);
+ setState(934);
+ match(CypherParser::FILTER);
+ setState(936);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(935);
+ match(CypherParser::SP);
+ }
+ setState(938);
+ match(CypherParser::T__5);
+ setState(940);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(939);
+ match(CypherParser::SP);
+ }
+ setState(942);
+ filterExpression();
+ setState(944);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(943);
+ match(CypherParser::SP);
+ }
+ setState(946);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ case 7: {
+ enterOuterAlt(_localctx, 7);
+ setState(948);
+ match(CypherParser::EXTRACT);
+ setState(950);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(949);
+ match(CypherParser::SP);
+ }
+ setState(952);
+ match(CypherParser::T__5);
+ setState(954);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(953);
+ match(CypherParser::SP);
+ }
+ setState(956);
+ filterExpression();
+ setState(958);
+ _errHandler->sync(this);
+
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 165, _ctx)) {
+ case 1: {
+ setState(957);
+ match(CypherParser::SP);
+ break;
+ }
+
+ }
+ setState(965);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::T__10 || _la == CypherParser::SP) {
+ setState(961);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(960);
+ match(CypherParser::SP);
+ }
+ setState(963);
+ match(CypherParser::T__10);
+ setState(964);
+ expression();
+ }
+ setState(967);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ case 8: {
+ enterOuterAlt(_localctx, 8);
+ setState(969);
+ match(CypherParser::ALL);
+ setState(971);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(970);
+ match(CypherParser::SP);
+ }
+ setState(973);
+ match(CypherParser::T__5);
+ setState(975);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(974);
+ match(CypherParser::SP);
+ }
+ setState(977);
+ filterExpression();
+ setState(979);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(978);
+ match(CypherParser::SP);
+ }
+ setState(981);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ case 9: {
+ enterOuterAlt(_localctx, 9);
+ setState(983);
+ match(CypherParser::ANY);
+ setState(985);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(984);
+ match(CypherParser::SP);
+ }
+ setState(987);
+ match(CypherParser::T__5);
+ setState(989);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(988);
+ match(CypherParser::SP);
+ }
+ setState(991);
+ filterExpression();
+ setState(993);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(992);
+ match(CypherParser::SP);
+ }
+ setState(995);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ case 10: {
+ enterOuterAlt(_localctx, 10);
+ setState(997);
+ match(CypherParser::NONE);
+ setState(999);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(998);
+ match(CypherParser::SP);
+ }
+ setState(1001);
+ match(CypherParser::T__5);
+ setState(1003);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1002);
+ match(CypherParser::SP);
+ }
+ setState(1005);
+ filterExpression();
+ setState(1007);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1006);
+ match(CypherParser::SP);
+ }
+ setState(1009);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ case 11: {
+ enterOuterAlt(_localctx, 11);
+ setState(1011);
+ match(CypherParser::SINGLE);
+ setState(1013);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1012);
+ match(CypherParser::SP);
+ }
+ setState(1015);
+ match(CypherParser::T__5);
+ setState(1017);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1016);
+ match(CypherParser::SP);
+ }
+ setState(1019);
+ filterExpression();
+ setState(1021);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1020);
+ match(CypherParser::SP);
+ }
+ setState(1023);
+ match(CypherParser::T__6);
+ break;
+ }
+
+ case 12: {
+ enterOuterAlt(_localctx, 12);
+ setState(1025);
+ relationshipsPattern();
+ break;
+ }
+
+ case 13: {
+ enterOuterAlt(_localctx, 13);
+ setState(1026);
+ parenthesizedExpression();
+ break;
+ }
+
+ case 14: {
+ enterOuterAlt(_localctx, 14);
+ setState(1027);
+ functionInvocation();
+ break;
+ }
+
+ case 15: {
+ enterOuterAlt(_localctx, 15);
+ setState(1028);
+ variable();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -6451,70 +6629,70 @@ CypherParser::AtomContext *CypherParser::atom() {
return _localctx;
}
-//----------------- LiteralContext
-//------------------------------------------------------------------
+//----------------- LiteralContext ------------------------------------------------------------------
-CypherParser::LiteralContext::LiteralContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::NumberLiteralContext *
-CypherParser::LiteralContext::numberLiteral() {
+CypherParser::NumberLiteralContext* CypherParser::LiteralContext::numberLiteral() {
return getRuleContext<CypherParser::NumberLiteralContext>(0);
}
-tree::TerminalNode *CypherParser::LiteralContext::StringLiteral() {
+tree::TerminalNode* CypherParser::LiteralContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
-CypherParser::BooleanLiteralContext *
-CypherParser::LiteralContext::booleanLiteral() {
+CypherParser::BooleanLiteralContext* CypherParser::LiteralContext::booleanLiteral() {
return getRuleContext<CypherParser::BooleanLiteralContext>(0);
}
-tree::TerminalNode *CypherParser::LiteralContext::CYPHERNULL() {
+tree::TerminalNode* CypherParser::LiteralContext::CYPHERNULL() {
return getToken(CypherParser::CYPHERNULL, 0);
}
-CypherParser::MapLiteralContext *CypherParser::LiteralContext::mapLiteral() {
+CypherParser::MapLiteralContext* CypherParser::LiteralContext::mapLiteral() {
return getRuleContext<CypherParser::MapLiteralContext>(0);
}
-CypherParser::ListLiteralContext *CypherParser::LiteralContext::listLiteral() {
+CypherParser::ListLiteralContext* CypherParser::LiteralContext::listLiteral() {
return getRuleContext<CypherParser::ListLiteralContext>(0);
}
+
size_t CypherParser::LiteralContext::getRuleIndex() const {
return CypherParser::RuleLiteral;
}
-void CypherParser::LiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->enterLiteral(this);
}
void CypherParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->exitLiteral(this);
}
-antlrcpp::Any CypherParser::LiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitLiteral(this);
else
return visitor->visitChildren(this);
}
-CypherParser::LiteralContext *CypherParser::literal() {
- LiteralContext *_localctx =
- _tracker.createInstance<LiteralContext>(_ctx, getState());
+CypherParser::LiteralContext* CypherParser::literal() {
+ LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
enterRule(_localctx, 110, CypherParser::RuleLiteral);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- setState(990);
+ setState(1037);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::HexInteger:
@@ -6523,14 +6701,14 @@ CypherParser::LiteralContext *CypherParser::literal() {
case CypherParser::ExponentDecimalReal:
case CypherParser::RegularDecimalReal: {
enterOuterAlt(_localctx, 1);
- setState(984);
+ setState(1031);
numberLiteral();
break;
}
case CypherParser::StringLiteral: {
enterOuterAlt(_localctx, 2);
- setState(985);
+ setState(1032);
match(CypherParser::StringLiteral);
break;
}
@@ -6538,37 +6716,38 @@ CypherParser::LiteralContext *CypherParser::literal() {
case CypherParser::TRUE:
case CypherParser::FALSE: {
enterOuterAlt(_localctx, 3);
- setState(986);
+ setState(1033);
booleanLiteral();
break;
}
case CypherParser::CYPHERNULL: {
enterOuterAlt(_localctx, 4);
- setState(987);
+ setState(1034);
match(CypherParser::CYPHERNULL);
break;
}
- case CypherParser::T__27: {
+ case CypherParser::T__25: {
enterOuterAlt(_localctx, 5);
- setState(988);
+ setState(1035);
mapLiteral();
break;
}
case CypherParser::T__7: {
enterOuterAlt(_localctx, 6);
- setState(989);
+ setState(1036);
listLiteral();
break;
}
- default:
- throw NoViableAltException(this);
+ default:
+ throw NoViableAltException(this);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -6577,66 +6756,69 @@ CypherParser::LiteralContext *CypherParser::literal() {
return _localctx;
}
-//----------------- BooleanLiteralContext
-//------------------------------------------------------------------
+//----------------- BooleanLiteralContext ------------------------------------------------------------------
-CypherParser::BooleanLiteralContext::BooleanLiteralContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::BooleanLiteralContext::BooleanLiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::BooleanLiteralContext::TRUE() {
+tree::TerminalNode* CypherParser::BooleanLiteralContext::TRUE() {
return getToken(CypherParser::TRUE, 0);
}
-tree::TerminalNode *CypherParser::BooleanLiteralContext::FALSE() {
+tree::TerminalNode* CypherParser::BooleanLiteralContext::FALSE() {
return getToken(CypherParser::FALSE, 0);
}
+
size_t CypherParser::BooleanLiteralContext::getRuleIndex() const {
return CypherParser::RuleBooleanLiteral;
}
-void CypherParser::BooleanLiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::BooleanLiteralContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterBooleanLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->enterBooleanLiteral(this);
}
-void CypherParser::BooleanLiteralContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::BooleanLiteralContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitBooleanLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->exitBooleanLiteral(this);
}
-antlrcpp::Any CypherParser::BooleanLiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::BooleanLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitBooleanLiteral(this);
else
return visitor->visitChildren(this);
}
-CypherParser::BooleanLiteralContext *CypherParser::booleanLiteral() {
- BooleanLiteralContext *_localctx =
- _tracker.createInstance<BooleanLiteralContext>(_ctx, getState());
+CypherParser::BooleanLiteralContext* CypherParser::booleanLiteral() {
+ BooleanLiteralContext *_localctx = _tracker.createInstance<BooleanLiteralContext>(_ctx, getState());
enterRule(_localctx, 112, CypherParser::RuleBooleanLiteral);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(992);
+ setState(1039);
_la = _input->LA(1);
if (!(_la == CypherParser::TRUE
- || _la == CypherParser::FALSE)) {
- _errHandler->recoverInline(this);
- } else {
+ || _la == CypherParser::FALSE)) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -6645,350 +6827,152 @@ CypherParser::BooleanLiteralContext *CypherParser::booleanLiteral() {
return _localctx;
}
-//----------------- ListLiteralContext
-//------------------------------------------------------------------
+//----------------- ListLiteralContext ------------------------------------------------------------------
-CypherParser::ListLiteralContext::ListLiteralContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::ListLiteralContext::ListLiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
std::vector<tree::TerminalNode *> CypherParser::ListLiteralContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::ListLiteralContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::ListLiteralContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
-std::vector<CypherParser::ExpressionContext *>
-CypherParser::ListLiteralContext::expression() {
+std::vector<CypherParser::ExpressionContext *> CypherParser::ListLiteralContext::expression() {
return getRuleContexts<CypherParser::ExpressionContext>();
}
-CypherParser::ExpressionContext *CypherParser::ListLiteralContext::expression(
- size_t i) {
+CypherParser::ExpressionContext* CypherParser::ListLiteralContext::expression(size_t i) {
return getRuleContext<CypherParser::ExpressionContext>(i);
}
+
size_t CypherParser::ListLiteralContext::getRuleIndex() const {
return CypherParser::RuleListLiteral;
}
-void CypherParser::ListLiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ListLiteralContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterListLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->enterListLiteral(this);
}
-void CypherParser::ListLiteralContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ListLiteralContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitListLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->exitListLiteral(this);
}
-antlrcpp::Any CypherParser::ListLiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::ListLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitListLiteral(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ListLiteralContext *CypherParser::listLiteral() {
- ListLiteralContext *_localctx =
- _tracker.createInstance<ListLiteralContext>(_ctx, getState());
+CypherParser::ListLiteralContext* CypherParser::listLiteral() {
+ ListLiteralContext *_localctx = _tracker.createInstance<ListLiteralContext>(_ctx, getState());
enterRule(_localctx, 114, CypherParser::RuleListLiteral);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(994);
+ setState(1041);
match(CypherParser::T__7);
- setState(996);
+ setState(1043);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(995);
+ setState(1042);
match(CypherParser::SP);
}
- setState(1015);
+ setState(1062);
_errHandler->sync(this);
_la = _input->LA(1);
- if ((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) &
- ((1ULL << CypherParser::T__5) | (1ULL << CypherParser::T__7) |
- (1ULL << CypherParser::T__13) | (1ULL << CypherParser::T__14) |
- (1ULL << CypherParser::T__27) | (1ULL << CypherParser::T__29) |
- (1ULL << CypherParser::StringLiteral) |
- (1ULL << CypherParser::HexInteger) |
- (1ULL << CypherParser::DecimalInteger) |
- (1ULL << CypherParser::OctalInteger) |
- (1ULL << CypherParser::HexLetter) |
- (1ULL << CypherParser::ExponentDecimalReal) |
- (1ULL << CypherParser::RegularDecimalReal))) != 0) ||
- ((((_la - 64) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) &
- ((1ULL << (CypherParser::UNION - 64)) |
- (1ULL << (CypherParser::ALL - 64)) |
- (1ULL << (CypherParser::OPTIONAL - 64)) |
- (1ULL << (CypherParser::MATCH - 64)) |
- (1ULL << (CypherParser::UNWIND - 64)) |
- (1ULL << (CypherParser::AS - 64)) |
- (1ULL << (CypherParser::MERGE - 64)) |
- (1ULL << (CypherParser::ON - 64)) |
- (1ULL << (CypherParser::CREATE - 64)) |
- (1ULL << (CypherParser::SET - 64)) |
- (1ULL << (CypherParser::DETACH - 64)) |
- (1ULL << (CypherParser::DELETE - 64)) |
- (1ULL << (CypherParser::REMOVE - 64)) |
- (1ULL << (CypherParser::WITH - 64)) |
- (1ULL << (CypherParser::DISTINCT - 64)) |
- (1ULL << (CypherParser::RETURN - 64)) |
- (1ULL << (CypherParser::ORDER - 64)) |
- (1ULL << (CypherParser::BY - 64)) |
- (1ULL << (CypherParser::L_SKIP - 64)) |
- (1ULL << (CypherParser::LIMIT - 64)) |
- (1ULL << (CypherParser::ASCENDING - 64)) |
- (1ULL << (CypherParser::ASC - 64)) |
- (1ULL << (CypherParser::DESCENDING - 64)) |
- (1ULL << (CypherParser::DESC - 64)) |
- (1ULL << (CypherParser::WHERE - 64)) |
- (1ULL << (CypherParser::OR - 64)) |
- (1ULL << (CypherParser::XOR - 64)) |
- (1ULL << (CypherParser::AND - 64)) |
- (1ULL << (CypherParser::NOT - 64)) |
- (1ULL << (CypherParser::IN - 64)) |
- (1ULL << (CypherParser::STARTS - 64)) |
- (1ULL << (CypherParser::ENDS - 64)) |
- (1ULL << (CypherParser::CONTAINS - 64)) |
- (1ULL << (CypherParser::IS - 64)) |
- (1ULL << (CypherParser::CYPHERNULL - 64)) |
- (1ULL << (CypherParser::COUNT - 64)) |
- (1ULL << (CypherParser::FILTER - 64)) |
- (1ULL << (CypherParser::EXTRACT - 64)) |
- (1ULL << (CypherParser::ANY - 64)) |
- (1ULL << (CypherParser::NONE - 64)) |
- (1ULL << (CypherParser::SINGLE - 64)) |
- (1ULL << (CypherParser::TRUE - 64)) |
- (1ULL << (CypherParser::FALSE - 64)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 64)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(998);
+ if ((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::T__5)
+ | (1ULL << CypherParser::T__7)
+ | (1ULL << CypherParser::T__12)
+ | (1ULL << CypherParser::T__13)
+ | (1ULL << CypherParser::T__25)
+ | (1ULL << CypherParser::T__27)
+ | (1ULL << CypherParser::StringLiteral)
+ | (1ULL << CypherParser::HexInteger)
+ | (1ULL << CypherParser::DecimalInteger)
+ | (1ULL << CypherParser::OctalInteger)
+ | (1ULL << CypherParser::HexLetter)
+ | (1ULL << CypherParser::ExponentDecimalReal)
+ | (1ULL << CypherParser::RegularDecimalReal)
+ | (1ULL << CypherParser::UNION)
+ | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
+ | (1ULL << (CypherParser::MATCH - 64))
+ | (1ULL << (CypherParser::UNWIND - 64))
+ | (1ULL << (CypherParser::AS - 64))
+ | (1ULL << (CypherParser::MERGE - 64))
+ | (1ULL << (CypherParser::ON - 64))
+ | (1ULL << (CypherParser::CREATE - 64))
+ | (1ULL << (CypherParser::SET - 64))
+ | (1ULL << (CypherParser::DETACH - 64))
+ | (1ULL << (CypherParser::DELETE - 64))
+ | (1ULL << (CypherParser::REMOVE - 64))
+ | (1ULL << (CypherParser::WITH - 64))
+ | (1ULL << (CypherParser::DISTINCT - 64))
+ | (1ULL << (CypherParser::RETURN - 64))
+ | (1ULL << (CypherParser::ORDER - 64))
+ | (1ULL << (CypherParser::BY - 64))
+ | (1ULL << (CypherParser::L_SKIP - 64))
+ | (1ULL << (CypherParser::LIMIT - 64))
+ | (1ULL << (CypherParser::ASCENDING - 64))
+ | (1ULL << (CypherParser::ASC - 64))
+ | (1ULL << (CypherParser::DESCENDING - 64))
+ | (1ULL << (CypherParser::DESC - 64))
+ | (1ULL << (CypherParser::WHERE - 64))
+ | (1ULL << (CypherParser::OR - 64))
+ | (1ULL << (CypherParser::XOR - 64))
+ | (1ULL << (CypherParser::AND - 64))
+ | (1ULL << (CypherParser::NOT - 64))
+ | (1ULL << (CypherParser::IN - 64))
+ | (1ULL << (CypherParser::STARTS - 64))
+ | (1ULL << (CypherParser::ENDS - 64))
+ | (1ULL << (CypherParser::CONTAINS - 64))
+ | (1ULL << (CypherParser::IS - 64))
+ | (1ULL << (CypherParser::CYPHERNULL - 64))
+ | (1ULL << (CypherParser::COUNT - 64))
+ | (1ULL << (CypherParser::FILTER - 64))
+ | (1ULL << (CypherParser::EXTRACT - 64))
+ | (1ULL << (CypherParser::ANY - 64))
+ | (1ULL << (CypherParser::NONE - 64))
+ | (1ULL << (CypherParser::SINGLE - 64))
+ | (1ULL << (CypherParser::TRUE - 64))
+ | (1ULL << (CypherParser::FALSE - 64))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
+ setState(1045);
expression();
- setState(1000);
+ setState(1047);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(999);
+ setState(1046);
match(CypherParser::SP);
}
- setState(1012);
+ setState(1059);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__1) {
- setState(1002);
- match(CypherParser::T__1);
- setState(1004);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1003);
- match(CypherParser::SP);
- }
- setState(1006);
- expression();
- setState(1008);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1007);
- match(CypherParser::SP);
- }
- setState(1014);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
- }
- setState(1017);
- match(CypherParser::T__9);
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PartialComparisonExpressionContext
-//------------------------------------------------------------------
-
-CypherParser::PartialComparisonExpressionContext::
- PartialComparisonExpressionContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::Expression7Context *
-CypherParser::PartialComparisonExpressionContext::expression7() {
- return getRuleContext<CypherParser::Expression7Context>(0);
-}
-
-tree::TerminalNode *CypherParser::PartialComparisonExpressionContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-size_t CypherParser::PartialComparisonExpressionContext::getRuleIndex() const {
- return CypherParser::RulePartialComparisonExpression;
-}
-
-void CypherParser::PartialComparisonExpressionContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterPartialComparisonExpression(this);
-}
-
-void CypherParser::PartialComparisonExpressionContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitPartialComparisonExpression(this);
-}
-
-antlrcpp::Any CypherParser::PartialComparisonExpressionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitPartialComparisonExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PartialComparisonExpressionContext *
-CypherParser::partialComparisonExpression() {
- PartialComparisonExpressionContext *_localctx =
- _tracker.createInstance<PartialComparisonExpressionContext>(_ctx,
- getState());
- enterRule(_localctx, 116, CypherParser::RulePartialComparisonExpression);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- setState(1054);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::T__2: {
- enterOuterAlt(_localctx, 1);
- setState(1019);
- match(CypherParser::T__2);
- setState(1021);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1020);
- match(CypherParser::SP);
- }
- setState(1023);
- expression7();
- break;
- }
-
- case CypherParser::T__19: {
- enterOuterAlt(_localctx, 2);
- setState(1024);
- match(CypherParser::T__19);
- setState(1026);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1025);
- match(CypherParser::SP);
- }
- setState(1028);
- expression7();
- break;
- }
-
- case CypherParser::T__20: {
- enterOuterAlt(_localctx, 3);
- setState(1029);
- match(CypherParser::T__20);
- setState(1031);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1030);
- match(CypherParser::SP);
- }
- setState(1033);
- expression7();
- break;
- }
-
- case CypherParser::T__21: {
- enterOuterAlt(_localctx, 4);
- setState(1034);
- match(CypherParser::T__21);
- setState(1036);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1035);
- match(CypherParser::SP);
- }
- setState(1038);
- expression7();
- break;
- }
-
- case CypherParser::T__22: {
- enterOuterAlt(_localctx, 5);
- setState(1039);
- match(CypherParser::T__22);
- setState(1041);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1040);
- match(CypherParser::SP);
- }
- setState(1043);
- expression7();
- break;
- }
-
- case CypherParser::T__23: {
- enterOuterAlt(_localctx, 6);
- setState(1044);
- match(CypherParser::T__23);
- setState(1046);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1045);
- match(CypherParser::SP);
- }
- setState(1048);
- expression7();
- break;
- }
-
- case CypherParser::T__24: {
- enterOuterAlt(_localctx, 7);
setState(1049);
- match(CypherParser::T__24);
+ match(CypherParser::T__1);
setState(1051);
_errHandler->sync(this);
@@ -6998,294 +6982,25 @@ CypherParser::partialComparisonExpression() {
match(CypherParser::SP);
}
setState(1053);
- expression7();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ParenthesizedExpressionContext
-//------------------------------------------------------------------
-
-CypherParser::ParenthesizedExpressionContext::ParenthesizedExpressionContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::ExpressionContext *
-CypherParser::ParenthesizedExpressionContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-std::vector<tree::TerminalNode *>
-CypherParser::ParenthesizedExpressionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode *CypherParser::ParenthesizedExpressionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-size_t CypherParser::ParenthesizedExpressionContext::getRuleIndex() const {
- return CypherParser::RuleParenthesizedExpression;
-}
-
-void CypherParser::ParenthesizedExpressionContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterParenthesizedExpression(this);
-}
-
-void CypherParser::ParenthesizedExpressionContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->exitParenthesizedExpression(this);
-}
-
-antlrcpp::Any CypherParser::ParenthesizedExpressionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitParenthesizedExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::ParenthesizedExpressionContext *
-CypherParser::parenthesizedExpression() {
- ParenthesizedExpressionContext *_localctx =
- _tracker.createInstance<ParenthesizedExpressionContext>(_ctx, getState());
- enterRule(_localctx, 118, CypherParser::RuleParenthesizedExpression);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1056);
- match(CypherParser::T__5);
- setState(1058);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1057);
- match(CypherParser::SP);
- }
- setState(1060);
- expression();
- setState(1062);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1061);
- match(CypherParser::SP);
- }
- setState(1064);
- match(CypherParser::T__6);
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- RelationshipsPatternContext
-//------------------------------------------------------------------
-
-CypherParser::RelationshipsPatternContext::RelationshipsPatternContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::NodePatternContext *
-CypherParser::RelationshipsPatternContext::nodePattern() {
- return getRuleContext<CypherParser::NodePatternContext>(0);
-}
-
-std::vector<CypherParser::PatternElementChainContext *>
-CypherParser::RelationshipsPatternContext::patternElementChain() {
- return getRuleContexts<CypherParser::PatternElementChainContext>();
-}
-
-CypherParser::PatternElementChainContext *
-CypherParser::RelationshipsPatternContext::patternElementChain(size_t i) {
- return getRuleContext<CypherParser::PatternElementChainContext>(i);
-}
-
-std::vector<tree::TerminalNode *>
-CypherParser::RelationshipsPatternContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode *CypherParser::RelationshipsPatternContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-size_t CypherParser::RelationshipsPatternContext::getRuleIndex() const {
- return CypherParser::RuleRelationshipsPattern;
-}
-
-void CypherParser::RelationshipsPatternContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr)
- parserListener->enterRelationshipsPattern(this);
-}
-
-void CypherParser::RelationshipsPatternContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRelationshipsPattern(this);
-}
-
-antlrcpp::Any CypherParser::RelationshipsPatternContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitRelationshipsPattern(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::RelationshipsPatternContext *
-CypherParser::relationshipsPattern() {
- RelationshipsPatternContext *_localctx =
- _tracker.createInstance<RelationshipsPatternContext>(_ctx, getState());
- enterRule(_localctx, 120, CypherParser::RuleRelationshipsPattern);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- size_t alt;
- enterOuterAlt(_localctx, 1);
- setState(1066);
- nodePattern();
- setState(1071);
- _errHandler->sync(this);
- alt = 1;
- do {
- switch (alt) {
- case 1: {
- setState(1068);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1067);
- match(CypherParser::SP);
- }
- setState(1070);
- patternElementChain();
- break;
- }
-
- default:
- throw NoViableAltException(this);
- }
- setState(1073);
- _errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 185, _ctx);
- } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- FilterExpressionContext
-//------------------------------------------------------------------
-
-CypherParser::FilterExpressionContext::FilterExpressionContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::IdInCollContext *
-CypherParser::FilterExpressionContext::idInColl() {
- return getRuleContext<CypherParser::IdInCollContext>(0);
-}
-
-CypherParser::WhereContext *CypherParser::FilterExpressionContext::where() {
- return getRuleContext<CypherParser::WhereContext>(0);
-}
-
-tree::TerminalNode *CypherParser::FilterExpressionContext::SP() {
- return getToken(CypherParser::SP, 0);
-}
-
-size_t CypherParser::FilterExpressionContext::getRuleIndex() const {
- return CypherParser::RuleFilterExpression;
-}
-
-void CypherParser::FilterExpressionContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterFilterExpression(this);
-}
-
-void CypherParser::FilterExpressionContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitFilterExpression(this);
-}
-
-antlrcpp::Any CypherParser::FilterExpressionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitFilterExpression(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::FilterExpressionContext *CypherParser::filterExpression() {
- FilterExpressionContext *_localctx =
- _tracker.createInstance<FilterExpressionContext>(_ctx, getState());
- enterRule(_localctx, 122, CypherParser::RuleFilterExpression);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1075);
- idInColl();
- setState(1080);
- _errHandler->sync(this);
-
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 187, _ctx)) {
- case 1: {
- setState(1077);
+ expression();
+ setState(1055);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(1076);
+ setState(1054);
match(CypherParser::SP);
}
- setState(1079);
- where();
- break;
+ setState(1061);
+ _errHandler->sync(this);
+ _la = _input->LA(1);
}
}
-
- } catch (RecognitionException &e) {
+ setState(1064);
+ match(CypherParser::T__8);
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -7294,181 +7009,163 @@ CypherParser::FilterExpressionContext *CypherParser::filterExpression() {
return _localctx;
}
-//----------------- IdInCollContext
-//------------------------------------------------------------------
+//----------------- PartialComparisonExpressionContext ------------------------------------------------------------------
-CypherParser::IdInCollContext::IdInCollContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::VariableContext *CypherParser::IdInCollContext::variable() {
- return getRuleContext<CypherParser::VariableContext>(0);
+CypherParser::PartialComparisonExpressionContext::PartialComparisonExpressionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
}
-std::vector<tree::TerminalNode *> CypherParser::IdInCollContext::SP() {
- return getTokens(CypherParser::SP);
+CypherParser::Expression7Context* CypherParser::PartialComparisonExpressionContext::expression7() {
+ return getRuleContext<CypherParser::Expression7Context>(0);
}
-tree::TerminalNode *CypherParser::IdInCollContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
+tree::TerminalNode* CypherParser::PartialComparisonExpressionContext::SP() {
+ return getToken(CypherParser::SP, 0);
}
-tree::TerminalNode *CypherParser::IdInCollContext::IN() {
- return getToken(CypherParser::IN, 0);
+
+size_t CypherParser::PartialComparisonExpressionContext::getRuleIndex() const {
+ return CypherParser::RulePartialComparisonExpression;
}
-CypherParser::ExpressionContext *CypherParser::IdInCollContext::expression() {
- return getRuleContext<CypherParser::ExpressionContext>(0);
-}
-
-size_t CypherParser::IdInCollContext::getRuleIndex() const {
- return CypherParser::RuleIdInColl;
-}
-
-void CypherParser::IdInCollContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PartialComparisonExpressionContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterIdInColl(this);
+ if (parserListener != nullptr)
+ parserListener->enterPartialComparisonExpression(this);
}
-void CypherParser::IdInCollContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PartialComparisonExpressionContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitIdInColl(this);
+ if (parserListener != nullptr)
+ parserListener->exitPartialComparisonExpression(this);
}
-antlrcpp::Any CypherParser::IdInCollContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitIdInColl(this);
+
+antlrcpp::Any CypherParser::PartialComparisonExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitPartialComparisonExpression(this);
else
return visitor->visitChildren(this);
}
-CypherParser::IdInCollContext *CypherParser::idInColl() {
- IdInCollContext *_localctx =
- _tracker.createInstance<IdInCollContext>(_ctx, getState());
- enterRule(_localctx, 124, CypherParser::RuleIdInColl);
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1082);
- variable();
- setState(1083);
- match(CypherParser::SP);
- setState(1084);
- match(CypherParser::IN);
- setState(1085);
- match(CypherParser::SP);
- setState(1086);
- expression();
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- FunctionInvocationContext
-//------------------------------------------------------------------
-
-CypherParser::FunctionInvocationContext::FunctionInvocationContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::FunctionNameContext *
-CypherParser::FunctionInvocationContext::functionName() {
- return getRuleContext<CypherParser::FunctionNameContext>(0);
-}
-
-std::vector<tree::TerminalNode *>
-CypherParser::FunctionInvocationContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode *CypherParser::FunctionInvocationContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-tree::TerminalNode *CypherParser::FunctionInvocationContext::DISTINCT() {
- return getToken(CypherParser::DISTINCT, 0);
-}
-
-std::vector<CypherParser::ExpressionContext *>
-CypherParser::FunctionInvocationContext::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext *
-CypherParser::FunctionInvocationContext::expression(size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-size_t CypherParser::FunctionInvocationContext::getRuleIndex() const {
- return CypherParser::RuleFunctionInvocation;
-}
-
-void CypherParser::FunctionInvocationContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterFunctionInvocation(this);
-}
-
-void CypherParser::FunctionInvocationContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitFunctionInvocation(this);
-}
-
-antlrcpp::Any CypherParser::FunctionInvocationContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitFunctionInvocation(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::FunctionInvocationContext *CypherParser::functionInvocation() {
- FunctionInvocationContext *_localctx =
- _tracker.createInstance<FunctionInvocationContext>(_ctx, getState());
- enterRule(_localctx, 126, CypherParser::RuleFunctionInvocation);
+CypherParser::PartialComparisonExpressionContext* CypherParser::partialComparisonExpression() {
+ PartialComparisonExpressionContext *_localctx = _tracker.createInstance<PartialComparisonExpressionContext>(_ctx, getState());
+ enterRule(_localctx, 116, CypherParser::RulePartialComparisonExpression);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
- enterOuterAlt(_localctx, 1);
- setState(1088);
- functionName();
- setState(1090);
+ setState(1101);
_errHandler->sync(this);
+ switch (_input->LA(1)) {
+ case CypherParser::T__2: {
+ enterOuterAlt(_localctx, 1);
+ setState(1066);
+ match(CypherParser::T__2);
+ setState(1068);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1089);
- match(CypherParser::SP);
- }
- setState(1092);
- match(CypherParser::T__5);
- setState(1094);
- _errHandler->sync(this);
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1067);
+ match(CypherParser::SP);
+ }
+ setState(1070);
+ expression7();
+ break;
+ }
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1093);
- match(CypherParser::SP);
- }
- setState(1100);
- _errHandler->sync(this);
+ case CypherParser::T__18: {
+ enterOuterAlt(_localctx, 2);
+ setState(1071);
+ match(CypherParser::T__18);
+ setState(1073);
+ _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 191, _ctx)) {
- case 1: {
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1072);
+ match(CypherParser::SP);
+ }
+ setState(1075);
+ expression7();
+ break;
+ }
+
+ case CypherParser::T__19: {
+ enterOuterAlt(_localctx, 3);
+ setState(1076);
+ match(CypherParser::T__19);
+ setState(1078);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1077);
+ match(CypherParser::SP);
+ }
+ setState(1080);
+ expression7();
+ break;
+ }
+
+ case CypherParser::T__20: {
+ enterOuterAlt(_localctx, 4);
+ setState(1081);
+ match(CypherParser::T__20);
+ setState(1083);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1082);
+ match(CypherParser::SP);
+ }
+ setState(1085);
+ expression7();
+ break;
+ }
+
+ case CypherParser::T__21: {
+ enterOuterAlt(_localctx, 5);
+ setState(1086);
+ match(CypherParser::T__21);
+ setState(1088);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1087);
+ match(CypherParser::SP);
+ }
+ setState(1090);
+ expression7();
+ break;
+ }
+
+ case CypherParser::T__22: {
+ enterOuterAlt(_localctx, 6);
+ setState(1091);
+ match(CypherParser::T__22);
+ setState(1093);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1092);
+ match(CypherParser::SP);
+ }
+ setState(1095);
+ expression7();
+ break;
+ }
+
+ case CypherParser::T__23: {
+ enterOuterAlt(_localctx, 7);
setState(1096);
- match(CypherParser::DISTINCT);
+ match(CypherParser::T__23);
setState(1098);
_errHandler->sync(this);
@@ -7477,115 +7174,17 @@ CypherParser::FunctionInvocationContext *CypherParser::functionInvocation() {
setState(1097);
match(CypherParser::SP);
}
+ setState(1100);
+ expression7();
break;
}
+
+ default:
+ throw NoViableAltException(this);
}
- setState(1119);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if ((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) &
- ((1ULL << CypherParser::T__5) | (1ULL << CypherParser::T__7) |
- (1ULL << CypherParser::T__13) | (1ULL << CypherParser::T__14) |
- (1ULL << CypherParser::T__27) | (1ULL << CypherParser::T__29) |
- (1ULL << CypherParser::StringLiteral) |
- (1ULL << CypherParser::HexInteger) |
- (1ULL << CypherParser::DecimalInteger) |
- (1ULL << CypherParser::OctalInteger) |
- (1ULL << CypherParser::HexLetter) |
- (1ULL << CypherParser::ExponentDecimalReal) |
- (1ULL << CypherParser::RegularDecimalReal))) != 0) ||
- ((((_la - 64) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 64)) &
- ((1ULL << (CypherParser::UNION - 64)) |
- (1ULL << (CypherParser::ALL - 64)) |
- (1ULL << (CypherParser::OPTIONAL - 64)) |
- (1ULL << (CypherParser::MATCH - 64)) |
- (1ULL << (CypherParser::UNWIND - 64)) |
- (1ULL << (CypherParser::AS - 64)) |
- (1ULL << (CypherParser::MERGE - 64)) |
- (1ULL << (CypherParser::ON - 64)) |
- (1ULL << (CypherParser::CREATE - 64)) |
- (1ULL << (CypherParser::SET - 64)) |
- (1ULL << (CypherParser::DETACH - 64)) |
- (1ULL << (CypherParser::DELETE - 64)) |
- (1ULL << (CypherParser::REMOVE - 64)) |
- (1ULL << (CypherParser::WITH - 64)) |
- (1ULL << (CypherParser::DISTINCT - 64)) |
- (1ULL << (CypherParser::RETURN - 64)) |
- (1ULL << (CypherParser::ORDER - 64)) |
- (1ULL << (CypherParser::BY - 64)) |
- (1ULL << (CypherParser::L_SKIP - 64)) |
- (1ULL << (CypherParser::LIMIT - 64)) |
- (1ULL << (CypherParser::ASCENDING - 64)) |
- (1ULL << (CypherParser::ASC - 64)) |
- (1ULL << (CypherParser::DESCENDING - 64)) |
- (1ULL << (CypherParser::DESC - 64)) |
- (1ULL << (CypherParser::WHERE - 64)) |
- (1ULL << (CypherParser::OR - 64)) |
- (1ULL << (CypherParser::XOR - 64)) |
- (1ULL << (CypherParser::AND - 64)) |
- (1ULL << (CypherParser::NOT - 64)) |
- (1ULL << (CypherParser::IN - 64)) |
- (1ULL << (CypherParser::STARTS - 64)) |
- (1ULL << (CypherParser::ENDS - 64)) |
- (1ULL << (CypherParser::CONTAINS - 64)) |
- (1ULL << (CypherParser::IS - 64)) |
- (1ULL << (CypherParser::CYPHERNULL - 64)) |
- (1ULL << (CypherParser::COUNT - 64)) |
- (1ULL << (CypherParser::FILTER - 64)) |
- (1ULL << (CypherParser::EXTRACT - 64)) |
- (1ULL << (CypherParser::ANY - 64)) |
- (1ULL << (CypherParser::NONE - 64)) |
- (1ULL << (CypherParser::SINGLE - 64)) |
- (1ULL << (CypherParser::TRUE - 64)) |
- (1ULL << (CypherParser::FALSE - 64)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 64)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
- setState(1102);
- expression();
- setState(1104);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1103);
- match(CypherParser::SP);
- }
- setState(1116);
- _errHandler->sync(this);
- _la = _input->LA(1);
- while (_la == CypherParser::T__1) {
- setState(1106);
- match(CypherParser::T__1);
- setState(1108);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1107);
- match(CypherParser::SP);
- }
- setState(1110);
- expression();
- setState(1112);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1111);
- match(CypherParser::SP);
- }
- setState(1118);
- _errHandler->sync(this);
- _la = _input->LA(1);
- }
- }
- setState(1121);
- match(CypherParser::T__6);
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -7594,179 +7193,436 @@ CypherParser::FunctionInvocationContext *CypherParser::functionInvocation() {
return _localctx;
}
-//----------------- FunctionNameContext
-//------------------------------------------------------------------
+//----------------- ParenthesizedExpressionContext ------------------------------------------------------------------
-CypherParser::FunctionNameContext::FunctionNameContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-tree::TerminalNode *CypherParser::FunctionNameContext::UnescapedSymbolicName() {
- return getToken(CypherParser::UnescapedSymbolicName, 0);
+CypherParser::ParenthesizedExpressionContext::ParenthesizedExpressionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
}
-tree::TerminalNode *CypherParser::FunctionNameContext::EscapedSymbolicName() {
- return getToken(CypherParser::EscapedSymbolicName, 0);
-}
-
-tree::TerminalNode *CypherParser::FunctionNameContext::COUNT() {
- return getToken(CypherParser::COUNT, 0);
-}
-
-size_t CypherParser::FunctionNameContext::getRuleIndex() const {
- return CypherParser::RuleFunctionName;
-}
-
-void CypherParser::FunctionNameContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterFunctionName(this);
-}
-
-void CypherParser::FunctionNameContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitFunctionName(this);
-}
-
-antlrcpp::Any CypherParser::FunctionNameContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitFunctionName(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::FunctionNameContext *CypherParser::functionName() {
- FunctionNameContext *_localctx =
- _tracker.createInstance<FunctionNameContext>(_ctx, getState());
- enterRule(_localctx, 128, CypherParser::RuleFunctionName);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1123);
- _la = _input->LA(1);
- if (!(((((_la - 99) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 99)) &
- ((1ULL << (CypherParser::COUNT - 99)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 99)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 99)))) != 0))) {
- _errHandler->recoverInline(this);
- } else {
- _errHandler->reportMatch(this);
- consume();
- }
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- ListComprehensionContext
-//------------------------------------------------------------------
-
-CypherParser::ListComprehensionContext::ListComprehensionContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::FilterExpressionContext *
-CypherParser::ListComprehensionContext::filterExpression() {
- return getRuleContext<CypherParser::FilterExpressionContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::ListComprehensionContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode *CypherParser::ListComprehensionContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-CypherParser::ExpressionContext *
-CypherParser::ListComprehensionContext::expression() {
+CypherParser::ExpressionContext* CypherParser::ParenthesizedExpressionContext::expression() {
return getRuleContext<CypherParser::ExpressionContext>(0);
}
-size_t CypherParser::ListComprehensionContext::getRuleIndex() const {
- return CypherParser::RuleListComprehension;
+std::vector<tree::TerminalNode *> CypherParser::ParenthesizedExpressionContext::SP() {
+ return getTokens(CypherParser::SP);
}
-void CypherParser::ListComprehensionContext::enterRule(
- tree::ParseTreeListener *listener) {
+tree::TerminalNode* CypherParser::ParenthesizedExpressionContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+
+size_t CypherParser::ParenthesizedExpressionContext::getRuleIndex() const {
+ return CypherParser::RuleParenthesizedExpression;
+}
+
+void CypherParser::ParenthesizedExpressionContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterListComprehension(this);
+ if (parserListener != nullptr)
+ parserListener->enterParenthesizedExpression(this);
}
-void CypherParser::ListComprehensionContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ParenthesizedExpressionContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitListComprehension(this);
+ if (parserListener != nullptr)
+ parserListener->exitParenthesizedExpression(this);
}
-antlrcpp::Any CypherParser::ListComprehensionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitListComprehension(this);
+
+antlrcpp::Any CypherParser::ParenthesizedExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitParenthesizedExpression(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ListComprehensionContext *CypherParser::listComprehension() {
- ListComprehensionContext *_localctx =
- _tracker.createInstance<ListComprehensionContext>(_ctx, getState());
- enterRule(_localctx, 130, CypherParser::RuleListComprehension);
+CypherParser::ParenthesizedExpressionContext* CypherParser::parenthesizedExpression() {
+ ParenthesizedExpressionContext *_localctx = _tracker.createInstance<ParenthesizedExpressionContext>(_ctx, getState());
+ enterRule(_localctx, 118, CypherParser::RuleParenthesizedExpression);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1125);
- match(CypherParser::T__7);
- setState(1127);
+ setState(1103);
+ match(CypherParser::T__5);
+ setState(1105);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
- setState(1126);
+ setState(1104);
match(CypherParser::SP);
}
- setState(1129);
- filterExpression();
- setState(1138);
+ setState(1107);
+ expression();
+ setState(1109);
_errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 200, _ctx)) {
- case 1: {
- setState(1131);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1130);
- match(CypherParser::SP);
- }
- setState(1133);
- match(CypherParser::T__11);
- setState(1135);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1134);
- match(CypherParser::SP);
- }
- setState(1137);
- expression();
- break;
- }
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1108);
+ match(CypherParser::SP);
}
+ setState(1111);
+ match(CypherParser::T__6);
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- RelationshipsPatternContext ------------------------------------------------------------------
+
+CypherParser::RelationshipsPatternContext::RelationshipsPatternContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::NodePatternContext* CypherParser::RelationshipsPatternContext::nodePattern() {
+ return getRuleContext<CypherParser::NodePatternContext>(0);
+}
+
+std::vector<CypherParser::PatternElementChainContext *> CypherParser::RelationshipsPatternContext::patternElementChain() {
+ return getRuleContexts<CypherParser::PatternElementChainContext>();
+}
+
+CypherParser::PatternElementChainContext* CypherParser::RelationshipsPatternContext::patternElementChain(size_t i) {
+ return getRuleContext<CypherParser::PatternElementChainContext>(i);
+}
+
+std::vector<tree::TerminalNode *> CypherParser::RelationshipsPatternContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::RelationshipsPatternContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+
+size_t CypherParser::RelationshipsPatternContext::getRuleIndex() const {
+ return CypherParser::RuleRelationshipsPattern;
+}
+
+void CypherParser::RelationshipsPatternContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterRelationshipsPattern(this);
+}
+
+void CypherParser::RelationshipsPatternContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitRelationshipsPattern(this);
+}
+
+
+antlrcpp::Any CypherParser::RelationshipsPatternContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitRelationshipsPattern(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::RelationshipsPatternContext* CypherParser::relationshipsPattern() {
+ RelationshipsPatternContext *_localctx = _tracker.createInstance<RelationshipsPatternContext>(_ctx, getState());
+ enterRule(_localctx, 120, CypherParser::RuleRelationshipsPattern);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ size_t alt;
+ enterOuterAlt(_localctx, 1);
+ setState(1113);
+ nodePattern();
+ setState(1118);
+ _errHandler->sync(this);
+ alt = 1;
+ do {
+ switch (alt) {
+ case 1: {
+ setState(1115);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1114);
+ match(CypherParser::SP);
+ }
+ setState(1117);
+ patternElementChain();
+ break;
+ }
+
+ default:
+ throw NoViableAltException(this);
+ }
+ setState(1120);
+ _errHandler->sync(this);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 199, _ctx);
+ } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- FilterExpressionContext ------------------------------------------------------------------
+
+CypherParser::FilterExpressionContext::FilterExpressionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::IdInCollContext* CypherParser::FilterExpressionContext::idInColl() {
+ return getRuleContext<CypherParser::IdInCollContext>(0);
+}
+
+CypherParser::WhereContext* CypherParser::FilterExpressionContext::where() {
+ return getRuleContext<CypherParser::WhereContext>(0);
+}
+
+tree::TerminalNode* CypherParser::FilterExpressionContext::SP() {
+ return getToken(CypherParser::SP, 0);
+}
+
+
+size_t CypherParser::FilterExpressionContext::getRuleIndex() const {
+ return CypherParser::RuleFilterExpression;
+}
+
+void CypherParser::FilterExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterFilterExpression(this);
+}
+
+void CypherParser::FilterExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitFilterExpression(this);
+}
+
+
+antlrcpp::Any CypherParser::FilterExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitFilterExpression(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::FilterExpressionContext* CypherParser::filterExpression() {
+ FilterExpressionContext *_localctx = _tracker.createInstance<FilterExpressionContext>(_ctx, getState());
+ enterRule(_localctx, 122, CypherParser::RuleFilterExpression);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1122);
+ idInColl();
+ setState(1127);
+ _errHandler->sync(this);
+
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 201, _ctx)) {
+ case 1: {
+ setState(1124);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1123);
+ match(CypherParser::SP);
+ }
+ setState(1126);
+ where();
+ break;
+ }
+
+ }
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- IdInCollContext ------------------------------------------------------------------
+
+CypherParser::IdInCollContext::IdInCollContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::VariableContext* CypherParser::IdInCollContext::variable() {
+ return getRuleContext<CypherParser::VariableContext>(0);
+}
+
+std::vector<tree::TerminalNode *> CypherParser::IdInCollContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::IdInCollContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+tree::TerminalNode* CypherParser::IdInCollContext::IN() {
+ return getToken(CypherParser::IN, 0);
+}
+
+CypherParser::ExpressionContext* CypherParser::IdInCollContext::expression() {
+ return getRuleContext<CypherParser::ExpressionContext>(0);
+}
+
+
+size_t CypherParser::IdInCollContext::getRuleIndex() const {
+ return CypherParser::RuleIdInColl;
+}
+
+void CypherParser::IdInCollContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterIdInColl(this);
+}
+
+void CypherParser::IdInCollContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitIdInColl(this);
+}
+
+
+antlrcpp::Any CypherParser::IdInCollContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitIdInColl(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::IdInCollContext* CypherParser::idInColl() {
+ IdInCollContext *_localctx = _tracker.createInstance<IdInCollContext>(_ctx, getState());
+ enterRule(_localctx, 124, CypherParser::RuleIdInColl);
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1129);
+ variable();
+ setState(1130);
+ match(CypherParser::SP);
+ setState(1131);
+ match(CypherParser::IN);
+ setState(1132);
+ match(CypherParser::SP);
+ setState(1133);
+ expression();
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- FunctionInvocationContext ------------------------------------------------------------------
+
+CypherParser::FunctionInvocationContext::FunctionInvocationContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::FunctionNameContext* CypherParser::FunctionInvocationContext::functionName() {
+ return getRuleContext<CypherParser::FunctionNameContext>(0);
+}
+
+std::vector<tree::TerminalNode *> CypherParser::FunctionInvocationContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::FunctionInvocationContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+tree::TerminalNode* CypherParser::FunctionInvocationContext::DISTINCT() {
+ return getToken(CypherParser::DISTINCT, 0);
+}
+
+std::vector<CypherParser::ExpressionContext *> CypherParser::FunctionInvocationContext::expression() {
+ return getRuleContexts<CypherParser::ExpressionContext>();
+}
+
+CypherParser::ExpressionContext* CypherParser::FunctionInvocationContext::expression(size_t i) {
+ return getRuleContext<CypherParser::ExpressionContext>(i);
+}
+
+
+size_t CypherParser::FunctionInvocationContext::getRuleIndex() const {
+ return CypherParser::RuleFunctionInvocation;
+}
+
+void CypherParser::FunctionInvocationContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterFunctionInvocation(this);
+}
+
+void CypherParser::FunctionInvocationContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitFunctionInvocation(this);
+}
+
+
+antlrcpp::Any CypherParser::FunctionInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitFunctionInvocation(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::FunctionInvocationContext* CypherParser::functionInvocation() {
+ FunctionInvocationContext *_localctx = _tracker.createInstance<FunctionInvocationContext>(_ctx, getState());
+ enterRule(_localctx, 126, CypherParser::RuleFunctionInvocation);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1135);
+ functionName();
+ setState(1137);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1136);
+ match(CypherParser::SP);
+ }
+ setState(1139);
+ match(CypherParser::T__5);
setState(1141);
_errHandler->sync(this);
@@ -7775,414 +7631,290 @@ CypherParser::ListComprehensionContext *CypherParser::listComprehension() {
setState(1140);
match(CypherParser::SP);
}
- setState(1143);
- match(CypherParser::T__9);
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- PropertyLookupContext
-//------------------------------------------------------------------
-
-CypherParser::PropertyLookupContext::PropertyLookupContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::PropertyKeyNameContext *
-CypherParser::PropertyLookupContext::propertyKeyName() {
- return getRuleContext<CypherParser::PropertyKeyNameContext>(0);
-}
-
-std::vector<tree::TerminalNode *> CypherParser::PropertyLookupContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode *CypherParser::PropertyLookupContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-size_t CypherParser::PropertyLookupContext::getRuleIndex() const {
- return CypherParser::RulePropertyLookup;
-}
-
-void CypherParser::PropertyLookupContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterPropertyLookup(this);
-}
-
-void CypherParser::PropertyLookupContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitPropertyLookup(this);
-}
-
-antlrcpp::Any CypherParser::PropertyLookupContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitPropertyLookup(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::PropertyLookupContext *CypherParser::propertyLookup() {
- PropertyLookupContext *_localctx =
- _tracker.createInstance<PropertyLookupContext>(_ctx, getState());
- enterRule(_localctx, 132, CypherParser::RulePropertyLookup);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1146);
+ setState(1147);
_errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 205, _ctx)) {
+ case 1: {
+ setState(1143);
+ match(CypherParser::DISTINCT);
setState(1145);
- match(CypherParser::SP);
- }
- setState(1148);
- match(CypherParser::T__25);
- setState(1150);
- _errHandler->sync(this);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1149);
- match(CypherParser::SP);
- }
- setState(1156);
- _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 204, _ctx)) {
- case 1: {
- setState(1152);
- propertyKeyName();
- setState(1153);
- _la = _input->LA(1);
- if (!(_la == CypherParser::T__8
-
- || _la == CypherParser::T__26)) {
- _errHandler->recoverInline(this);
- } else {
- _errHandler->reportMatch(this);
- consume();
- }
- break;
- }
-
- case 2: {
- setState(1155);
- propertyKeyName();
- break;
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1144);
+ match(CypherParser::SP);
}
+ break;
}
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- VariableContext
-//------------------------------------------------------------------
-
-CypherParser::VariableContext::VariableContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::SymbolicNameContext *
-CypherParser::VariableContext::symbolicName() {
- return getRuleContext<CypherParser::SymbolicNameContext>(0);
-}
-
-size_t CypherParser::VariableContext::getRuleIndex() const {
- return CypherParser::RuleVariable;
-}
-
-void CypherParser::VariableContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterVariable(this);
-}
-
-void CypherParser::VariableContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitVariable(this);
-}
-
-antlrcpp::Any CypherParser::VariableContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitVariable(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::VariableContext *CypherParser::variable() {
- VariableContext *_localctx =
- _tracker.createInstance<VariableContext>(_ctx, getState());
- enterRule(_localctx, 134, CypherParser::RuleVariable);
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1158);
- symbolicName();
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- NumberLiteralContext
-//------------------------------------------------------------------
-
-CypherParser::NumberLiteralContext::NumberLiteralContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-CypherParser::DoubleLiteralContext *
-CypherParser::NumberLiteralContext::doubleLiteral() {
- return getRuleContext<CypherParser::DoubleLiteralContext>(0);
-}
-
-CypherParser::IntegerLiteralContext *
-CypherParser::NumberLiteralContext::integerLiteral() {
- return getRuleContext<CypherParser::IntegerLiteralContext>(0);
-}
-
-size_t CypherParser::NumberLiteralContext::getRuleIndex() const {
- return CypherParser::RuleNumberLiteral;
-}
-
-void CypherParser::NumberLiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterNumberLiteral(this);
-}
-
-void CypherParser::NumberLiteralContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitNumberLiteral(this);
-}
-
-antlrcpp::Any CypherParser::NumberLiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitNumberLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::NumberLiteralContext *CypherParser::numberLiteral() {
- NumberLiteralContext *_localctx =
- _tracker.createInstance<NumberLiteralContext>(_ctx, getState());
- enterRule(_localctx, 136, CypherParser::RuleNumberLiteral);
-
- auto onExit = finally([=] { exitRule(); });
- try {
- setState(1162);
- _errHandler->sync(this);
- switch (_input->LA(1)) {
- case CypherParser::ExponentDecimalReal:
- case CypherParser::RegularDecimalReal: {
- enterOuterAlt(_localctx, 1);
- setState(1160);
- doubleLiteral();
- break;
- }
-
- case CypherParser::HexInteger:
- case CypherParser::DecimalInteger:
- case CypherParser::OctalInteger: {
- enterOuterAlt(_localctx, 2);
- setState(1161);
- integerLiteral();
- break;
- }
-
- default:
- throw NoViableAltException(this);
}
-
- } catch (RecognitionException &e) {
- _errHandler->reportError(this, e);
- _localctx->exception = std::current_exception();
- _errHandler->recover(this, _localctx->exception);
- }
-
- return _localctx;
-}
-
-//----------------- MapLiteralContext
-//------------------------------------------------------------------
-
-CypherParser::MapLiteralContext::MapLiteralContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
-
-std::vector<tree::TerminalNode *> CypherParser::MapLiteralContext::SP() {
- return getTokens(CypherParser::SP);
-}
-
-tree::TerminalNode *CypherParser::MapLiteralContext::SP(size_t i) {
- return getToken(CypherParser::SP, i);
-}
-
-std::vector<CypherParser::PropertyKeyNameContext *>
-CypherParser::MapLiteralContext::propertyKeyName() {
- return getRuleContexts<CypherParser::PropertyKeyNameContext>();
-}
-
-CypherParser::PropertyKeyNameContext *
-CypherParser::MapLiteralContext::propertyKeyName(size_t i) {
- return getRuleContext<CypherParser::PropertyKeyNameContext>(i);
-}
-
-std::vector<CypherParser::ExpressionContext *>
-CypherParser::MapLiteralContext::expression() {
- return getRuleContexts<CypherParser::ExpressionContext>();
-}
-
-CypherParser::ExpressionContext *CypherParser::MapLiteralContext::expression(
- size_t i) {
- return getRuleContext<CypherParser::ExpressionContext>(i);
-}
-
-size_t CypherParser::MapLiteralContext::getRuleIndex() const {
- return CypherParser::RuleMapLiteral;
-}
-
-void CypherParser::MapLiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterMapLiteral(this);
-}
-
-void CypherParser::MapLiteralContext::exitRule(
- tree::ParseTreeListener *listener) {
- auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitMapLiteral(this);
-}
-
-antlrcpp::Any CypherParser::MapLiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
- return parserVisitor->visitMapLiteral(this);
- else
- return visitor->visitChildren(this);
-}
-
-CypherParser::MapLiteralContext *CypherParser::mapLiteral() {
- MapLiteralContext *_localctx =
- _tracker.createInstance<MapLiteralContext>(_ctx, getState());
- enterRule(_localctx, 138, CypherParser::RuleMapLiteral);
- size_t _la = 0;
-
- auto onExit = finally([=] { exitRule(); });
- try {
- enterOuterAlt(_localctx, 1);
- setState(1164);
- match(CypherParser::T__27);
setState(1166);
_errHandler->sync(this);
_la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1165);
- match(CypherParser::SP);
+ if ((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::T__5)
+ | (1ULL << CypherParser::T__7)
+ | (1ULL << CypherParser::T__12)
+ | (1ULL << CypherParser::T__13)
+ | (1ULL << CypherParser::T__25)
+ | (1ULL << CypherParser::T__27)
+ | (1ULL << CypherParser::StringLiteral)
+ | (1ULL << CypherParser::HexInteger)
+ | (1ULL << CypherParser::DecimalInteger)
+ | (1ULL << CypherParser::OctalInteger)
+ | (1ULL << CypherParser::HexLetter)
+ | (1ULL << CypherParser::ExponentDecimalReal)
+ | (1ULL << CypherParser::RegularDecimalReal)
+ | (1ULL << CypherParser::UNION)
+ | (1ULL << CypherParser::ALL))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 64)) & ((1ULL << (CypherParser::OPTIONAL - 64))
+ | (1ULL << (CypherParser::MATCH - 64))
+ | (1ULL << (CypherParser::UNWIND - 64))
+ | (1ULL << (CypherParser::AS - 64))
+ | (1ULL << (CypherParser::MERGE - 64))
+ | (1ULL << (CypherParser::ON - 64))
+ | (1ULL << (CypherParser::CREATE - 64))
+ | (1ULL << (CypherParser::SET - 64))
+ | (1ULL << (CypherParser::DETACH - 64))
+ | (1ULL << (CypherParser::DELETE - 64))
+ | (1ULL << (CypherParser::REMOVE - 64))
+ | (1ULL << (CypherParser::WITH - 64))
+ | (1ULL << (CypherParser::DISTINCT - 64))
+ | (1ULL << (CypherParser::RETURN - 64))
+ | (1ULL << (CypherParser::ORDER - 64))
+ | (1ULL << (CypherParser::BY - 64))
+ | (1ULL << (CypherParser::L_SKIP - 64))
+ | (1ULL << (CypherParser::LIMIT - 64))
+ | (1ULL << (CypherParser::ASCENDING - 64))
+ | (1ULL << (CypherParser::ASC - 64))
+ | (1ULL << (CypherParser::DESCENDING - 64))
+ | (1ULL << (CypherParser::DESC - 64))
+ | (1ULL << (CypherParser::WHERE - 64))
+ | (1ULL << (CypherParser::OR - 64))
+ | (1ULL << (CypherParser::XOR - 64))
+ | (1ULL << (CypherParser::AND - 64))
+ | (1ULL << (CypherParser::NOT - 64))
+ | (1ULL << (CypherParser::IN - 64))
+ | (1ULL << (CypherParser::STARTS - 64))
+ | (1ULL << (CypherParser::ENDS - 64))
+ | (1ULL << (CypherParser::CONTAINS - 64))
+ | (1ULL << (CypherParser::IS - 64))
+ | (1ULL << (CypherParser::CYPHERNULL - 64))
+ | (1ULL << (CypherParser::COUNT - 64))
+ | (1ULL << (CypherParser::FILTER - 64))
+ | (1ULL << (CypherParser::EXTRACT - 64))
+ | (1ULL << (CypherParser::ANY - 64))
+ | (1ULL << (CypherParser::NONE - 64))
+ | (1ULL << (CypherParser::SINGLE - 64))
+ | (1ULL << (CypherParser::TRUE - 64))
+ | (1ULL << (CypherParser::FALSE - 64))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 64))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 64)))) != 0)) {
+ setState(1149);
+ expression();
+ setState(1151);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1150);
+ match(CypherParser::SP);
+ }
+ setState(1163);
+ _errHandler->sync(this);
+ _la = _input->LA(1);
+ while (_la == CypherParser::T__1) {
+ setState(1153);
+ match(CypherParser::T__1);
+ setState(1155);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1154);
+ match(CypherParser::SP);
+ }
+ setState(1157);
+ expression();
+ setState(1159);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1158);
+ match(CypherParser::SP);
+ }
+ setState(1165);
+ _errHandler->sync(this);
+ _la = _input->LA(1);
+ }
}
- setState(1201);
+ setState(1168);
+ match(CypherParser::T__6);
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- FunctionNameContext ------------------------------------------------------------------
+
+CypherParser::FunctionNameContext::FunctionNameContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* CypherParser::FunctionNameContext::UnescapedSymbolicName() {
+ return getToken(CypherParser::UnescapedSymbolicName, 0);
+}
+
+tree::TerminalNode* CypherParser::FunctionNameContext::EscapedSymbolicName() {
+ return getToken(CypherParser::EscapedSymbolicName, 0);
+}
+
+tree::TerminalNode* CypherParser::FunctionNameContext::COUNT() {
+ return getToken(CypherParser::COUNT, 0);
+}
+
+
+size_t CypherParser::FunctionNameContext::getRuleIndex() const {
+ return CypherParser::RuleFunctionName;
+}
+
+void CypherParser::FunctionNameContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterFunctionName(this);
+}
+
+void CypherParser::FunctionNameContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitFunctionName(this);
+}
+
+
+antlrcpp::Any CypherParser::FunctionNameContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitFunctionName(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::FunctionNameContext* CypherParser::functionName() {
+ FunctionNameContext *_localctx = _tracker.createInstance<FunctionNameContext>(_ctx, getState());
+ enterRule(_localctx, 128, CypherParser::RuleFunctionName);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1170);
+ _la = _input->LA(1);
+ if (!(((((_la - 97) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 97)) & ((1ULL << (CypherParser::COUNT - 97))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 97))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 97)))) != 0))) {
+ _errHandler->recoverInline(this);
+ }
+ else {
+ _errHandler->reportMatch(this);
+ consume();
+ }
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- ListComprehensionContext ------------------------------------------------------------------
+
+CypherParser::ListComprehensionContext::ListComprehensionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::FilterExpressionContext* CypherParser::ListComprehensionContext::filterExpression() {
+ return getRuleContext<CypherParser::FilterExpressionContext>(0);
+}
+
+std::vector<tree::TerminalNode *> CypherParser::ListComprehensionContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::ListComprehensionContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+CypherParser::ExpressionContext* CypherParser::ListComprehensionContext::expression() {
+ return getRuleContext<CypherParser::ExpressionContext>(0);
+}
+
+
+size_t CypherParser::ListComprehensionContext::getRuleIndex() const {
+ return CypherParser::RuleListComprehension;
+}
+
+void CypherParser::ListComprehensionContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterListComprehension(this);
+}
+
+void CypherParser::ListComprehensionContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitListComprehension(this);
+}
+
+
+antlrcpp::Any CypherParser::ListComprehensionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitListComprehension(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::ListComprehensionContext* CypherParser::listComprehension() {
+ ListComprehensionContext *_localctx = _tracker.createInstance<ListComprehensionContext>(_ctx, getState());
+ enterRule(_localctx, 130, CypherParser::RuleListComprehension);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1172);
+ match(CypherParser::T__7);
+ setState(1174);
_errHandler->sync(this);
_la = _input->LA(1);
- if (((((_la - 55) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 55)) &
- ((1ULL << (CypherParser::HexLetter - 55)) |
- (1ULL << (CypherParser::UNION - 55)) |
- (1ULL << (CypherParser::ALL - 55)) |
- (1ULL << (CypherParser::OPTIONAL - 55)) |
- (1ULL << (CypherParser::MATCH - 55)) |
- (1ULL << (CypherParser::UNWIND - 55)) |
- (1ULL << (CypherParser::AS - 55)) |
- (1ULL << (CypherParser::MERGE - 55)) |
- (1ULL << (CypherParser::ON - 55)) |
- (1ULL << (CypherParser::CREATE - 55)) |
- (1ULL << (CypherParser::SET - 55)) |
- (1ULL << (CypherParser::DETACH - 55)) |
- (1ULL << (CypherParser::DELETE - 55)) |
- (1ULL << (CypherParser::REMOVE - 55)) |
- (1ULL << (CypherParser::WITH - 55)) |
- (1ULL << (CypherParser::DISTINCT - 55)) |
- (1ULL << (CypherParser::RETURN - 55)) |
- (1ULL << (CypherParser::ORDER - 55)) |
- (1ULL << (CypherParser::BY - 55)) |
- (1ULL << (CypherParser::L_SKIP - 55)) |
- (1ULL << (CypherParser::LIMIT - 55)) |
- (1ULL << (CypherParser::ASCENDING - 55)) |
- (1ULL << (CypherParser::ASC - 55)) |
- (1ULL << (CypherParser::DESCENDING - 55)) |
- (1ULL << (CypherParser::DESC - 55)) |
- (1ULL << (CypherParser::WHERE - 55)) |
- (1ULL << (CypherParser::OR - 55)) |
- (1ULL << (CypherParser::XOR - 55)) |
- (1ULL << (CypherParser::AND - 55)) |
- (1ULL << (CypherParser::NOT - 55)) |
- (1ULL << (CypherParser::IN - 55)) |
- (1ULL << (CypherParser::STARTS - 55)) |
- (1ULL << (CypherParser::ENDS - 55)) |
- (1ULL << (CypherParser::CONTAINS - 55)) |
- (1ULL << (CypherParser::IS - 55)) |
- (1ULL << (CypherParser::CYPHERNULL - 55)) |
- (1ULL << (CypherParser::COUNT - 55)) |
- (1ULL << (CypherParser::FILTER - 55)) |
- (1ULL << (CypherParser::EXTRACT - 55)) |
- (1ULL << (CypherParser::ANY - 55)) |
- (1ULL << (CypherParser::NONE - 55)) |
- (1ULL << (CypherParser::SINGLE - 55)) |
- (1ULL << (CypherParser::TRUE - 55)) |
- (1ULL << (CypherParser::FALSE - 55)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 55)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 55)))) != 0)) {
- setState(1168);
- propertyKeyName();
- setState(1170);
- _errHandler->sync(this);
+ if (_la == CypherParser::SP) {
+ setState(1173);
+ match(CypherParser::SP);
+ }
+ setState(1176);
+ filterExpression();
+ setState(1185);
+ _errHandler->sync(this);
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1169);
- match(CypherParser::SP);
- }
- setState(1172);
- match(CypherParser::T__10);
- setState(1174);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1173);
- match(CypherParser::SP);
- }
- setState(1176);
- expression();
+ switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 214, _ctx)) {
+ case 1: {
setState(1178);
_errHandler->sync(this);
@@ -8191,59 +7923,35 @@ CypherParser::MapLiteralContext *CypherParser::mapLiteral() {
setState(1177);
match(CypherParser::SP);
}
- setState(1198);
+ setState(1180);
+ match(CypherParser::T__10);
+ setState(1182);
_errHandler->sync(this);
+
_la = _input->LA(1);
- while (_la == CypherParser::T__1) {
- setState(1180);
- match(CypherParser::T__1);
- setState(1182);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1181);
- match(CypherParser::SP);
- }
- setState(1184);
- propertyKeyName();
- setState(1186);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1185);
- match(CypherParser::SP);
- }
- setState(1188);
- match(CypherParser::T__10);
- setState(1190);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1189);
- match(CypherParser::SP);
- }
- setState(1192);
- expression();
- setState(1194);
- _errHandler->sync(this);
-
- _la = _input->LA(1);
- if (_la == CypherParser::SP) {
- setState(1193);
- match(CypherParser::SP);
- }
- setState(1200);
- _errHandler->sync(this);
- _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1181);
+ match(CypherParser::SP);
}
+ setState(1184);
+ expression();
+ break;
}
- setState(1203);
- match(CypherParser::T__28);
- } catch (RecognitionException &e) {
+ }
+ setState(1188);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1187);
+ match(CypherParser::SP);
+ }
+ setState(1190);
+ match(CypherParser::T__8);
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -8252,57 +7960,706 @@ CypherParser::MapLiteralContext *CypherParser::mapLiteral() {
return _localctx;
}
-//----------------- ParameterContext
-//------------------------------------------------------------------
+//----------------- PatternComprehensionContext ------------------------------------------------------------------
-CypherParser::ParameterContext::ParameterContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PatternComprehensionContext::PatternComprehensionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::SymbolicNameContext *
-CypherParser::ParameterContext::symbolicName() {
+CypherParser::RelationshipsPatternContext* CypherParser::PatternComprehensionContext::relationshipsPattern() {
+ return getRuleContext<CypherParser::RelationshipsPatternContext>(0);
+}
+
+std::vector<CypherParser::ExpressionContext *> CypherParser::PatternComprehensionContext::expression() {
+ return getRuleContexts<CypherParser::ExpressionContext>();
+}
+
+CypherParser::ExpressionContext* CypherParser::PatternComprehensionContext::expression(size_t i) {
+ return getRuleContext<CypherParser::ExpressionContext>(i);
+}
+
+std::vector<tree::TerminalNode *> CypherParser::PatternComprehensionContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::PatternComprehensionContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+CypherParser::VariableContext* CypherParser::PatternComprehensionContext::variable() {
+ return getRuleContext<CypherParser::VariableContext>(0);
+}
+
+tree::TerminalNode* CypherParser::PatternComprehensionContext::WHERE() {
+ return getToken(CypherParser::WHERE, 0);
+}
+
+
+size_t CypherParser::PatternComprehensionContext::getRuleIndex() const {
+ return CypherParser::RulePatternComprehension;
+}
+
+void CypherParser::PatternComprehensionContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterPatternComprehension(this);
+}
+
+void CypherParser::PatternComprehensionContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitPatternComprehension(this);
+}
+
+
+antlrcpp::Any CypherParser::PatternComprehensionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitPatternComprehension(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::PatternComprehensionContext* CypherParser::patternComprehension() {
+ PatternComprehensionContext *_localctx = _tracker.createInstance<PatternComprehensionContext>(_ctx, getState());
+ enterRule(_localctx, 132, CypherParser::RulePatternComprehension);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1192);
+ match(CypherParser::T__7);
+ setState(1194);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1193);
+ match(CypherParser::SP);
+ }
+ setState(1204);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (((((_la - 53) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
+ | (1ULL << (CypherParser::UNION - 53))
+ | (1ULL << (CypherParser::ALL - 53))
+ | (1ULL << (CypherParser::OPTIONAL - 53))
+ | (1ULL << (CypherParser::MATCH - 53))
+ | (1ULL << (CypherParser::UNWIND - 53))
+ | (1ULL << (CypherParser::AS - 53))
+ | (1ULL << (CypherParser::MERGE - 53))
+ | (1ULL << (CypherParser::ON - 53))
+ | (1ULL << (CypherParser::CREATE - 53))
+ | (1ULL << (CypherParser::SET - 53))
+ | (1ULL << (CypherParser::DETACH - 53))
+ | (1ULL << (CypherParser::DELETE - 53))
+ | (1ULL << (CypherParser::REMOVE - 53))
+ | (1ULL << (CypherParser::WITH - 53))
+ | (1ULL << (CypherParser::DISTINCT - 53))
+ | (1ULL << (CypherParser::RETURN - 53))
+ | (1ULL << (CypherParser::ORDER - 53))
+ | (1ULL << (CypherParser::BY - 53))
+ | (1ULL << (CypherParser::L_SKIP - 53))
+ | (1ULL << (CypherParser::LIMIT - 53))
+ | (1ULL << (CypherParser::ASCENDING - 53))
+ | (1ULL << (CypherParser::ASC - 53))
+ | (1ULL << (CypherParser::DESCENDING - 53))
+ | (1ULL << (CypherParser::DESC - 53))
+ | (1ULL << (CypherParser::WHERE - 53))
+ | (1ULL << (CypherParser::OR - 53))
+ | (1ULL << (CypherParser::XOR - 53))
+ | (1ULL << (CypherParser::AND - 53))
+ | (1ULL << (CypherParser::NOT - 53))
+ | (1ULL << (CypherParser::IN - 53))
+ | (1ULL << (CypherParser::STARTS - 53))
+ | (1ULL << (CypherParser::ENDS - 53))
+ | (1ULL << (CypherParser::CONTAINS - 53))
+ | (1ULL << (CypherParser::IS - 53))
+ | (1ULL << (CypherParser::CYPHERNULL - 53))
+ | (1ULL << (CypherParser::COUNT - 53))
+ | (1ULL << (CypherParser::FILTER - 53))
+ | (1ULL << (CypherParser::EXTRACT - 53))
+ | (1ULL << (CypherParser::ANY - 53))
+ | (1ULL << (CypherParser::NONE - 53))
+ | (1ULL << (CypherParser::SINGLE - 53))
+ | (1ULL << (CypherParser::TRUE - 53))
+ | (1ULL << (CypherParser::FALSE - 53))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
+ setState(1196);
+ variable();
+ setState(1198);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1197);
+ match(CypherParser::SP);
+ }
+ setState(1200);
+ match(CypherParser::T__2);
+ setState(1202);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1201);
+ match(CypherParser::SP);
+ }
+ }
+ setState(1206);
+ relationshipsPattern();
+ setState(1208);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1207);
+ match(CypherParser::SP);
+ }
+ setState(1218);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::WHERE) {
+ setState(1210);
+ match(CypherParser::WHERE);
+ setState(1212);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1211);
+ match(CypherParser::SP);
+ }
+ setState(1214);
+ expression();
+ setState(1216);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1215);
+ match(CypherParser::SP);
+ }
+ }
+ setState(1220);
+ match(CypherParser::T__10);
+ setState(1222);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1221);
+ match(CypherParser::SP);
+ }
+ setState(1224);
+ expression();
+ setState(1226);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1225);
+ match(CypherParser::SP);
+ }
+ setState(1228);
+ match(CypherParser::T__8);
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- PropertyLookupContext ------------------------------------------------------------------
+
+CypherParser::PropertyLookupContext::PropertyLookupContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::PropertyKeyNameContext* CypherParser::PropertyLookupContext::propertyKeyName() {
+ return getRuleContext<CypherParser::PropertyKeyNameContext>(0);
+}
+
+tree::TerminalNode* CypherParser::PropertyLookupContext::SP() {
+ return getToken(CypherParser::SP, 0);
+}
+
+
+size_t CypherParser::PropertyLookupContext::getRuleIndex() const {
+ return CypherParser::RulePropertyLookup;
+}
+
+void CypherParser::PropertyLookupContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterPropertyLookup(this);
+}
+
+void CypherParser::PropertyLookupContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitPropertyLookup(this);
+}
+
+
+antlrcpp::Any CypherParser::PropertyLookupContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitPropertyLookup(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::PropertyLookupContext* CypherParser::propertyLookup() {
+ PropertyLookupContext *_localctx = _tracker.createInstance<PropertyLookupContext>(_ctx, getState());
+ enterRule(_localctx, 134, CypherParser::RulePropertyLookup);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1230);
+ match(CypherParser::T__24);
+ setState(1232);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1231);
+ match(CypherParser::SP);
+ }
+
+ setState(1234);
+ propertyKeyName();
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- VariableContext ------------------------------------------------------------------
+
+CypherParser::VariableContext::VariableContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::SymbolicNameContext* CypherParser::VariableContext::symbolicName() {
return getRuleContext<CypherParser::SymbolicNameContext>(0);
}
-tree::TerminalNode *CypherParser::ParameterContext::DecimalInteger() {
+
+size_t CypherParser::VariableContext::getRuleIndex() const {
+ return CypherParser::RuleVariable;
+}
+
+void CypherParser::VariableContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterVariable(this);
+}
+
+void CypherParser::VariableContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitVariable(this);
+}
+
+
+antlrcpp::Any CypherParser::VariableContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitVariable(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::VariableContext* CypherParser::variable() {
+ VariableContext *_localctx = _tracker.createInstance<VariableContext>(_ctx, getState());
+ enterRule(_localctx, 136, CypherParser::RuleVariable);
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1236);
+ symbolicName();
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- NumberLiteralContext ------------------------------------------------------------------
+
+CypherParser::NumberLiteralContext::NumberLiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::DoubleLiteralContext* CypherParser::NumberLiteralContext::doubleLiteral() {
+ return getRuleContext<CypherParser::DoubleLiteralContext>(0);
+}
+
+CypherParser::IntegerLiteralContext* CypherParser::NumberLiteralContext::integerLiteral() {
+ return getRuleContext<CypherParser::IntegerLiteralContext>(0);
+}
+
+
+size_t CypherParser::NumberLiteralContext::getRuleIndex() const {
+ return CypherParser::RuleNumberLiteral;
+}
+
+void CypherParser::NumberLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterNumberLiteral(this);
+}
+
+void CypherParser::NumberLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitNumberLiteral(this);
+}
+
+
+antlrcpp::Any CypherParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitNumberLiteral(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::NumberLiteralContext* CypherParser::numberLiteral() {
+ NumberLiteralContext *_localctx = _tracker.createInstance<NumberLiteralContext>(_ctx, getState());
+ enterRule(_localctx, 138, CypherParser::RuleNumberLiteral);
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ setState(1240);
+ _errHandler->sync(this);
+ switch (_input->LA(1)) {
+ case CypherParser::ExponentDecimalReal:
+ case CypherParser::RegularDecimalReal: {
+ enterOuterAlt(_localctx, 1);
+ setState(1238);
+ doubleLiteral();
+ break;
+ }
+
+ case CypherParser::HexInteger:
+ case CypherParser::DecimalInteger:
+ case CypherParser::OctalInteger: {
+ enterOuterAlt(_localctx, 2);
+ setState(1239);
+ integerLiteral();
+ break;
+ }
+
+ default:
+ throw NoViableAltException(this);
+ }
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- MapLiteralContext ------------------------------------------------------------------
+
+CypherParser::MapLiteralContext::MapLiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<tree::TerminalNode *> CypherParser::MapLiteralContext::SP() {
+ return getTokens(CypherParser::SP);
+}
+
+tree::TerminalNode* CypherParser::MapLiteralContext::SP(size_t i) {
+ return getToken(CypherParser::SP, i);
+}
+
+std::vector<CypherParser::PropertyKeyNameContext *> CypherParser::MapLiteralContext::propertyKeyName() {
+ return getRuleContexts<CypherParser::PropertyKeyNameContext>();
+}
+
+CypherParser::PropertyKeyNameContext* CypherParser::MapLiteralContext::propertyKeyName(size_t i) {
+ return getRuleContext<CypherParser::PropertyKeyNameContext>(i);
+}
+
+std::vector<CypherParser::ExpressionContext *> CypherParser::MapLiteralContext::expression() {
+ return getRuleContexts<CypherParser::ExpressionContext>();
+}
+
+CypherParser::ExpressionContext* CypherParser::MapLiteralContext::expression(size_t i) {
+ return getRuleContext<CypherParser::ExpressionContext>(i);
+}
+
+
+size_t CypherParser::MapLiteralContext::getRuleIndex() const {
+ return CypherParser::RuleMapLiteral;
+}
+
+void CypherParser::MapLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->enterMapLiteral(this);
+}
+
+void CypherParser::MapLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+ auto parserListener = dynamic_cast<CypherListener *>(listener);
+ if (parserListener != nullptr)
+ parserListener->exitMapLiteral(this);
+}
+
+
+antlrcpp::Any CypherParser::MapLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
+ return parserVisitor->visitMapLiteral(this);
+ else
+ return visitor->visitChildren(this);
+}
+
+CypherParser::MapLiteralContext* CypherParser::mapLiteral() {
+ MapLiteralContext *_localctx = _tracker.createInstance<MapLiteralContext>(_ctx, getState());
+ enterRule(_localctx, 140, CypherParser::RuleMapLiteral);
+ size_t _la = 0;
+
+ auto onExit = finally([=] {
+ exitRule();
+ });
+ try {
+ enterOuterAlt(_localctx, 1);
+ setState(1242);
+ match(CypherParser::T__25);
+ setState(1244);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1243);
+ match(CypherParser::SP);
+ }
+ setState(1279);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (((((_la - 53) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
+ | (1ULL << (CypherParser::UNION - 53))
+ | (1ULL << (CypherParser::ALL - 53))
+ | (1ULL << (CypherParser::OPTIONAL - 53))
+ | (1ULL << (CypherParser::MATCH - 53))
+ | (1ULL << (CypherParser::UNWIND - 53))
+ | (1ULL << (CypherParser::AS - 53))
+ | (1ULL << (CypherParser::MERGE - 53))
+ | (1ULL << (CypherParser::ON - 53))
+ | (1ULL << (CypherParser::CREATE - 53))
+ | (1ULL << (CypherParser::SET - 53))
+ | (1ULL << (CypherParser::DETACH - 53))
+ | (1ULL << (CypherParser::DELETE - 53))
+ | (1ULL << (CypherParser::REMOVE - 53))
+ | (1ULL << (CypherParser::WITH - 53))
+ | (1ULL << (CypherParser::DISTINCT - 53))
+ | (1ULL << (CypherParser::RETURN - 53))
+ | (1ULL << (CypherParser::ORDER - 53))
+ | (1ULL << (CypherParser::BY - 53))
+ | (1ULL << (CypherParser::L_SKIP - 53))
+ | (1ULL << (CypherParser::LIMIT - 53))
+ | (1ULL << (CypherParser::ASCENDING - 53))
+ | (1ULL << (CypherParser::ASC - 53))
+ | (1ULL << (CypherParser::DESCENDING - 53))
+ | (1ULL << (CypherParser::DESC - 53))
+ | (1ULL << (CypherParser::WHERE - 53))
+ | (1ULL << (CypherParser::OR - 53))
+ | (1ULL << (CypherParser::XOR - 53))
+ | (1ULL << (CypherParser::AND - 53))
+ | (1ULL << (CypherParser::NOT - 53))
+ | (1ULL << (CypherParser::IN - 53))
+ | (1ULL << (CypherParser::STARTS - 53))
+ | (1ULL << (CypherParser::ENDS - 53))
+ | (1ULL << (CypherParser::CONTAINS - 53))
+ | (1ULL << (CypherParser::IS - 53))
+ | (1ULL << (CypherParser::CYPHERNULL - 53))
+ | (1ULL << (CypherParser::COUNT - 53))
+ | (1ULL << (CypherParser::FILTER - 53))
+ | (1ULL << (CypherParser::EXTRACT - 53))
+ | (1ULL << (CypherParser::ANY - 53))
+ | (1ULL << (CypherParser::NONE - 53))
+ | (1ULL << (CypherParser::SINGLE - 53))
+ | (1ULL << (CypherParser::TRUE - 53))
+ | (1ULL << (CypherParser::FALSE - 53))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0)) {
+ setState(1246);
+ propertyKeyName();
+ setState(1248);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1247);
+ match(CypherParser::SP);
+ }
+ setState(1250);
+ match(CypherParser::T__9);
+ setState(1252);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1251);
+ match(CypherParser::SP);
+ }
+ setState(1254);
+ expression();
+ setState(1256);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1255);
+ match(CypherParser::SP);
+ }
+ setState(1276);
+ _errHandler->sync(this);
+ _la = _input->LA(1);
+ while (_la == CypherParser::T__1) {
+ setState(1258);
+ match(CypherParser::T__1);
+ setState(1260);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1259);
+ match(CypherParser::SP);
+ }
+ setState(1262);
+ propertyKeyName();
+ setState(1264);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1263);
+ match(CypherParser::SP);
+ }
+ setState(1266);
+ match(CypherParser::T__9);
+ setState(1268);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1267);
+ match(CypherParser::SP);
+ }
+ setState(1270);
+ expression();
+ setState(1272);
+ _errHandler->sync(this);
+
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1271);
+ match(CypherParser::SP);
+ }
+ setState(1278);
+ _errHandler->sync(this);
+ _la = _input->LA(1);
+ }
+ }
+ setState(1281);
+ match(CypherParser::T__26);
+
+ }
+ catch (RecognitionException &e) {
+ _errHandler->reportError(this, e);
+ _localctx->exception = std::current_exception();
+ _errHandler->recover(this, _localctx->exception);
+ }
+
+ return _localctx;
+}
+
+//----------------- ParameterContext ------------------------------------------------------------------
+
+CypherParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
+
+CypherParser::SymbolicNameContext* CypherParser::ParameterContext::symbolicName() {
+ return getRuleContext<CypherParser::SymbolicNameContext>(0);
+}
+
+tree::TerminalNode* CypherParser::ParameterContext::DecimalInteger() {
return getToken(CypherParser::DecimalInteger, 0);
}
+
size_t CypherParser::ParameterContext::getRuleIndex() const {
return CypherParser::RuleParameter;
}
-void CypherParser::ParameterContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ParameterContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterParameter(this);
+ if (parserListener != nullptr)
+ parserListener->enterParameter(this);
}
-void CypherParser::ParameterContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitParameter(this);
+ if (parserListener != nullptr)
+ parserListener->exitParameter(this);
}
-antlrcpp::Any CypherParser::ParameterContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::ParameterContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitParameter(this);
else
return visitor->visitChildren(this);
}
-CypherParser::ParameterContext *CypherParser::parameter() {
- ParameterContext *_localctx =
- _tracker.createInstance<ParameterContext>(_ctx, getState());
- enterRule(_localctx, 140, CypherParser::RuleParameter);
+CypherParser::ParameterContext* CypherParser::parameter() {
+ ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());
+ enterRule(_localctx, 142, CypherParser::RuleParameter);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1205);
- match(CypherParser::T__29);
- setState(1208);
+ setState(1283);
+ match(CypherParser::T__27);
+ setState(1286);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::HexLetter:
@@ -8351,22 +8708,23 @@ CypherParser::ParameterContext *CypherParser::parameter() {
case CypherParser::FALSE:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
- setState(1206);
+ setState(1284);
symbolicName();
break;
}
case CypherParser::DecimalInteger: {
- setState(1207);
+ setState(1285);
match(CypherParser::DecimalInteger);
break;
}
- default:
- throw NoViableAltException(this);
+ default:
+ throw NoViableAltException(this);
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -8375,103 +8733,99 @@ CypherParser::ParameterContext *CypherParser::parameter() {
return _localctx;
}
-//----------------- PropertyExpressionContext
-//------------------------------------------------------------------
+//----------------- PropertyExpressionContext ------------------------------------------------------------------
-CypherParser::PropertyExpressionContext::PropertyExpressionContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PropertyExpressionContext::PropertyExpressionContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::AtomContext *CypherParser::PropertyExpressionContext::atom() {
+CypherParser::AtomContext* CypherParser::PropertyExpressionContext::atom() {
return getRuleContext<CypherParser::AtomContext>(0);
}
-std::vector<CypherParser::PropertyLookupContext *>
-CypherParser::PropertyExpressionContext::propertyLookup() {
+std::vector<CypherParser::PropertyLookupContext *> CypherParser::PropertyExpressionContext::propertyLookup() {
return getRuleContexts<CypherParser::PropertyLookupContext>();
}
-CypherParser::PropertyLookupContext *
-CypherParser::PropertyExpressionContext::propertyLookup(size_t i) {
+CypherParser::PropertyLookupContext* CypherParser::PropertyExpressionContext::propertyLookup(size_t i) {
return getRuleContext<CypherParser::PropertyLookupContext>(i);
}
-std::vector<tree::TerminalNode *>
-CypherParser::PropertyExpressionContext::SP() {
+std::vector<tree::TerminalNode *> CypherParser::PropertyExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
-tree::TerminalNode *CypherParser::PropertyExpressionContext::SP(size_t i) {
+tree::TerminalNode* CypherParser::PropertyExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
+
size_t CypherParser::PropertyExpressionContext::getRuleIndex() const {
return CypherParser::RulePropertyExpression;
}
-void CypherParser::PropertyExpressionContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PropertyExpressionContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterPropertyExpression(this);
+ if (parserListener != nullptr)
+ parserListener->enterPropertyExpression(this);
}
-void CypherParser::PropertyExpressionContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PropertyExpressionContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitPropertyExpression(this);
+ if (parserListener != nullptr)
+ parserListener->exitPropertyExpression(this);
}
-antlrcpp::Any CypherParser::PropertyExpressionContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::PropertyExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitPropertyExpression(this);
else
return visitor->visitChildren(this);
}
-CypherParser::PropertyExpressionContext *CypherParser::propertyExpression() {
- PropertyExpressionContext *_localctx =
- _tracker.createInstance<PropertyExpressionContext>(_ctx, getState());
- enterRule(_localctx, 142, CypherParser::RulePropertyExpression);
+CypherParser::PropertyExpressionContext* CypherParser::propertyExpression() {
+ PropertyExpressionContext *_localctx = _tracker.createInstance<PropertyExpressionContext>(_ctx, getState());
+ enterRule(_localctx, 144, CypherParser::RulePropertyExpression);
+ size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
size_t alt;
enterOuterAlt(_localctx, 1);
- setState(1210);
+ setState(1288);
atom();
- setState(1215);
+ setState(1293);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
- setState(1212);
- _errHandler->sync(this);
+ setState(1290);
+ _errHandler->sync(this);
- switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 217, _ctx)) {
- case 1: {
- setState(1211);
- match(CypherParser::SP);
+ _la = _input->LA(1);
+ if (_la == CypherParser::SP) {
+ setState(1289);
+ match(CypherParser::SP);
+ }
+ setState(1292);
+ propertyLookup();
break;
}
- }
- setState(1214);
- propertyLookup();
- break;
- }
- default:
- throw NoViableAltException(this);
+ default:
+ throw NoViableAltException(this);
}
- setState(1217);
+ setState(1295);
_errHandler->sync(this);
- alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(
- _input, 218, _ctx);
+ alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 240, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -8480,54 +8834,55 @@ CypherParser::PropertyExpressionContext *CypherParser::propertyExpression() {
return _localctx;
}
-//----------------- PropertyKeyNameContext
-//------------------------------------------------------------------
+//----------------- PropertyKeyNameContext ------------------------------------------------------------------
-CypherParser::PropertyKeyNameContext::PropertyKeyNameContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::PropertyKeyNameContext::PropertyKeyNameContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::SymbolicNameContext *
-CypherParser::PropertyKeyNameContext::symbolicName() {
+CypherParser::SymbolicNameContext* CypherParser::PropertyKeyNameContext::symbolicName() {
return getRuleContext<CypherParser::SymbolicNameContext>(0);
}
+
size_t CypherParser::PropertyKeyNameContext::getRuleIndex() const {
return CypherParser::RulePropertyKeyName;
}
-void CypherParser::PropertyKeyNameContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PropertyKeyNameContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterPropertyKeyName(this);
+ if (parserListener != nullptr)
+ parserListener->enterPropertyKeyName(this);
}
-void CypherParser::PropertyKeyNameContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::PropertyKeyNameContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitPropertyKeyName(this);
+ if (parserListener != nullptr)
+ parserListener->exitPropertyKeyName(this);
}
-antlrcpp::Any CypherParser::PropertyKeyNameContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::PropertyKeyNameContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitPropertyKeyName(this);
else
return visitor->visitChildren(this);
}
-CypherParser::PropertyKeyNameContext *CypherParser::propertyKeyName() {
- PropertyKeyNameContext *_localctx =
- _tracker.createInstance<PropertyKeyNameContext>(_ctx, getState());
- enterRule(_localctx, 144, CypherParser::RulePropertyKeyName);
+CypherParser::PropertyKeyNameContext* CypherParser::propertyKeyName() {
+ PropertyKeyNameContext *_localctx = _tracker.createInstance<PropertyKeyNameContext>(_ctx, getState());
+ enterRule(_localctx, 146, CypherParser::RulePropertyKeyName);
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1219);
+ setState(1297);
symbolicName();
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -8536,71 +8891,74 @@ CypherParser::PropertyKeyNameContext *CypherParser::propertyKeyName() {
return _localctx;
}
-//----------------- IntegerLiteralContext
-//------------------------------------------------------------------
+//----------------- IntegerLiteralContext ------------------------------------------------------------------
-CypherParser::IntegerLiteralContext::IntegerLiteralContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::IntegerLiteralContext::IntegerLiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::IntegerLiteralContext::HexInteger() {
+tree::TerminalNode* CypherParser::IntegerLiteralContext::HexInteger() {
return getToken(CypherParser::HexInteger, 0);
}
-tree::TerminalNode *CypherParser::IntegerLiteralContext::OctalInteger() {
+tree::TerminalNode* CypherParser::IntegerLiteralContext::OctalInteger() {
return getToken(CypherParser::OctalInteger, 0);
}
-tree::TerminalNode *CypherParser::IntegerLiteralContext::DecimalInteger() {
+tree::TerminalNode* CypherParser::IntegerLiteralContext::DecimalInteger() {
return getToken(CypherParser::DecimalInteger, 0);
}
+
size_t CypherParser::IntegerLiteralContext::getRuleIndex() const {
return CypherParser::RuleIntegerLiteral;
}
-void CypherParser::IntegerLiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::IntegerLiteralContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterIntegerLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->enterIntegerLiteral(this);
}
-void CypherParser::IntegerLiteralContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::IntegerLiteralContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitIntegerLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->exitIntegerLiteral(this);
}
-antlrcpp::Any CypherParser::IntegerLiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::IntegerLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitIntegerLiteral(this);
else
return visitor->visitChildren(this);
}
-CypherParser::IntegerLiteralContext *CypherParser::integerLiteral() {
- IntegerLiteralContext *_localctx =
- _tracker.createInstance<IntegerLiteralContext>(_ctx, getState());
- enterRule(_localctx, 146, CypherParser::RuleIntegerLiteral);
+CypherParser::IntegerLiteralContext* CypherParser::integerLiteral() {
+ IntegerLiteralContext *_localctx = _tracker.createInstance<IntegerLiteralContext>(_ctx, getState());
+ enterRule(_localctx, 148, CypherParser::RuleIntegerLiteral);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1221);
+ setState(1299);
_la = _input->LA(1);
- if (!((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) & ((1ULL << CypherParser::HexInteger) |
- (1ULL << CypherParser::DecimalInteger) |
- (1ULL << CypherParser::OctalInteger))) != 0))) {
- _errHandler->recoverInline(this);
- } else {
+ if (!((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::HexInteger)
+ | (1ULL << CypherParser::DecimalInteger)
+ | (1ULL << CypherParser::OctalInteger))) != 0))) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -8609,66 +8967,69 @@ CypherParser::IntegerLiteralContext *CypherParser::integerLiteral() {
return _localctx;
}
-//----------------- DoubleLiteralContext
-//------------------------------------------------------------------
+//----------------- DoubleLiteralContext ------------------------------------------------------------------
-CypherParser::DoubleLiteralContext::DoubleLiteralContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::DoubleLiteralContext::DoubleLiteralContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::DoubleLiteralContext::ExponentDecimalReal() {
+tree::TerminalNode* CypherParser::DoubleLiteralContext::ExponentDecimalReal() {
return getToken(CypherParser::ExponentDecimalReal, 0);
}
-tree::TerminalNode *CypherParser::DoubleLiteralContext::RegularDecimalReal() {
+tree::TerminalNode* CypherParser::DoubleLiteralContext::RegularDecimalReal() {
return getToken(CypherParser::RegularDecimalReal, 0);
}
+
size_t CypherParser::DoubleLiteralContext::getRuleIndex() const {
return CypherParser::RuleDoubleLiteral;
}
-void CypherParser::DoubleLiteralContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::DoubleLiteralContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterDoubleLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->enterDoubleLiteral(this);
}
-void CypherParser::DoubleLiteralContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::DoubleLiteralContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitDoubleLiteral(this);
+ if (parserListener != nullptr)
+ parserListener->exitDoubleLiteral(this);
}
-antlrcpp::Any CypherParser::DoubleLiteralContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::DoubleLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitDoubleLiteral(this);
else
return visitor->visitChildren(this);
}
-CypherParser::DoubleLiteralContext *CypherParser::doubleLiteral() {
- DoubleLiteralContext *_localctx =
- _tracker.createInstance<DoubleLiteralContext>(_ctx, getState());
- enterRule(_localctx, 148, CypherParser::RuleDoubleLiteral);
+CypherParser::DoubleLiteralContext* CypherParser::doubleLiteral() {
+ DoubleLiteralContext *_localctx = _tracker.createInstance<DoubleLiteralContext>(_ctx, getState());
+ enterRule(_localctx, 150, CypherParser::RuleDoubleLiteral);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1223);
+ setState(1301);
_la = _input->LA(1);
if (!(_la == CypherParser::ExponentDecimalReal
- || _la == CypherParser::RegularDecimalReal)) {
- _errHandler->recoverInline(this);
- } else {
+ || _la == CypherParser::RegularDecimalReal)) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -8677,287 +9038,289 @@ CypherParser::DoubleLiteralContext *CypherParser::doubleLiteral() {
return _localctx;
}
-//----------------- SymbolicNameContext
-//------------------------------------------------------------------
+//----------------- SymbolicNameContext ------------------------------------------------------------------
-CypherParser::SymbolicNameContext::SymbolicNameContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
+CypherParser::SymbolicNameContext::SymbolicNameContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-tree::TerminalNode *CypherParser::SymbolicNameContext::UnescapedSymbolicName() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::UnescapedSymbolicName() {
return getToken(CypherParser::UnescapedSymbolicName, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::EscapedSymbolicName() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::EscapedSymbolicName() {
return getToken(CypherParser::EscapedSymbolicName, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::UNION() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::UNION() {
return getToken(CypherParser::UNION, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::ALL() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::ALL() {
return getToken(CypherParser::ALL, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::OPTIONAL() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::OPTIONAL() {
return getToken(CypherParser::OPTIONAL, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::MATCH() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::MATCH() {
return getToken(CypherParser::MATCH, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::UNWIND() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::UNWIND() {
return getToken(CypherParser::UNWIND, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::AS() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::AS() {
return getToken(CypherParser::AS, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::MERGE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::MERGE() {
return getToken(CypherParser::MERGE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::ON() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::ON() {
return getToken(CypherParser::ON, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::CREATE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::SET() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::SET() {
return getToken(CypherParser::SET, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::DETACH() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::DETACH() {
return getToken(CypherParser::DETACH, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::DELETE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::DELETE() {
return getToken(CypherParser::DELETE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::REMOVE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::REMOVE() {
return getToken(CypherParser::REMOVE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::WITH() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::DISTINCT() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::DISTINCT() {
return getToken(CypherParser::DISTINCT, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::RETURN() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::RETURN() {
return getToken(CypherParser::RETURN, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::ORDER() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::ORDER() {
return getToken(CypherParser::ORDER, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::BY() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::BY() {
return getToken(CypherParser::BY, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::L_SKIP() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::L_SKIP() {
return getToken(CypherParser::L_SKIP, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::LIMIT() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::LIMIT() {
return getToken(CypherParser::LIMIT, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::ASCENDING() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::ASCENDING() {
return getToken(CypherParser::ASCENDING, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::ASC() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::ASC() {
return getToken(CypherParser::ASC, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::DESCENDING() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::DESCENDING() {
return getToken(CypherParser::DESCENDING, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::DESC() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::DESC() {
return getToken(CypherParser::DESC, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::WHERE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::WHERE() {
return getToken(CypherParser::WHERE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::OR() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::OR() {
return getToken(CypherParser::OR, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::XOR() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::XOR() {
return getToken(CypherParser::XOR, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::AND() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::AND() {
return getToken(CypherParser::AND, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::NOT() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::NOT() {
return getToken(CypherParser::NOT, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::IN() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::IN() {
return getToken(CypherParser::IN, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::STARTS() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::STARTS() {
return getToken(CypherParser::STARTS, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::ENDS() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::ENDS() {
return getToken(CypherParser::ENDS, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::CONTAINS() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::CONTAINS() {
return getToken(CypherParser::CONTAINS, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::IS() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::IS() {
return getToken(CypherParser::IS, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::CYPHERNULL() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::CYPHERNULL() {
return getToken(CypherParser::CYPHERNULL, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::COUNT() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::COUNT() {
return getToken(CypherParser::COUNT, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::FILTER() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::FILTER() {
return getToken(CypherParser::FILTER, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::EXTRACT() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::EXTRACT() {
return getToken(CypherParser::EXTRACT, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::ANY() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::ANY() {
return getToken(CypherParser::ANY, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::NONE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::NONE() {
return getToken(CypherParser::NONE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::SINGLE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::SINGLE() {
return getToken(CypherParser::SINGLE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::TRUE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::TRUE() {
return getToken(CypherParser::TRUE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::FALSE() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::FALSE() {
return getToken(CypherParser::FALSE, 0);
}
-tree::TerminalNode *CypherParser::SymbolicNameContext::HexLetter() {
+tree::TerminalNode* CypherParser::SymbolicNameContext::HexLetter() {
return getToken(CypherParser::HexLetter, 0);
}
+
size_t CypherParser::SymbolicNameContext::getRuleIndex() const {
return CypherParser::RuleSymbolicName;
}
-void CypherParser::SymbolicNameContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::SymbolicNameContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterSymbolicName(this);
+ if (parserListener != nullptr)
+ parserListener->enterSymbolicName(this);
}
-void CypherParser::SymbolicNameContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::SymbolicNameContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitSymbolicName(this);
+ if (parserListener != nullptr)
+ parserListener->exitSymbolicName(this);
}
-antlrcpp::Any CypherParser::SymbolicNameContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::SymbolicNameContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitSymbolicName(this);
else
return visitor->visitChildren(this);
}
-CypherParser::SymbolicNameContext *CypherParser::symbolicName() {
- SymbolicNameContext *_localctx =
- _tracker.createInstance<SymbolicNameContext>(_ctx, getState());
- enterRule(_localctx, 150, CypherParser::RuleSymbolicName);
+CypherParser::SymbolicNameContext* CypherParser::symbolicName() {
+ SymbolicNameContext *_localctx = _tracker.createInstance<SymbolicNameContext>(_ctx, getState());
+ enterRule(_localctx, 152, CypherParser::RuleSymbolicName);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1225);
+ setState(1303);
_la = _input->LA(1);
- if (!(((((_la - 55) & ~0x3fULL) == 0) &&
- ((1ULL << (_la - 55)) &
- ((1ULL << (CypherParser::HexLetter - 55)) |
- (1ULL << (CypherParser::UNION - 55)) |
- (1ULL << (CypherParser::ALL - 55)) |
- (1ULL << (CypherParser::OPTIONAL - 55)) |
- (1ULL << (CypherParser::MATCH - 55)) |
- (1ULL << (CypherParser::UNWIND - 55)) |
- (1ULL << (CypherParser::AS - 55)) |
- (1ULL << (CypherParser::MERGE - 55)) |
- (1ULL << (CypherParser::ON - 55)) |
- (1ULL << (CypherParser::CREATE - 55)) |
- (1ULL << (CypherParser::SET - 55)) |
- (1ULL << (CypherParser::DETACH - 55)) |
- (1ULL << (CypherParser::DELETE - 55)) |
- (1ULL << (CypherParser::REMOVE - 55)) |
- (1ULL << (CypherParser::WITH - 55)) |
- (1ULL << (CypherParser::DISTINCT - 55)) |
- (1ULL << (CypherParser::RETURN - 55)) |
- (1ULL << (CypherParser::ORDER - 55)) |
- (1ULL << (CypherParser::BY - 55)) |
- (1ULL << (CypherParser::L_SKIP - 55)) |
- (1ULL << (CypherParser::LIMIT - 55)) |
- (1ULL << (CypherParser::ASCENDING - 55)) |
- (1ULL << (CypherParser::ASC - 55)) |
- (1ULL << (CypherParser::DESCENDING - 55)) |
- (1ULL << (CypherParser::DESC - 55)) |
- (1ULL << (CypherParser::WHERE - 55)) |
- (1ULL << (CypherParser::OR - 55)) |
- (1ULL << (CypherParser::XOR - 55)) |
- (1ULL << (CypherParser::AND - 55)) |
- (1ULL << (CypherParser::NOT - 55)) |
- (1ULL << (CypherParser::IN - 55)) |
- (1ULL << (CypherParser::STARTS - 55)) |
- (1ULL << (CypherParser::ENDS - 55)) |
- (1ULL << (CypherParser::CONTAINS - 55)) |
- (1ULL << (CypherParser::IS - 55)) |
- (1ULL << (CypherParser::CYPHERNULL - 55)) |
- (1ULL << (CypherParser::COUNT - 55)) |
- (1ULL << (CypherParser::FILTER - 55)) |
- (1ULL << (CypherParser::EXTRACT - 55)) |
- (1ULL << (CypherParser::ANY - 55)) |
- (1ULL << (CypherParser::NONE - 55)) |
- (1ULL << (CypherParser::SINGLE - 55)) |
- (1ULL << (CypherParser::TRUE - 55)) |
- (1ULL << (CypherParser::FALSE - 55)) |
- (1ULL << (CypherParser::UnescapedSymbolicName - 55)) |
- (1ULL << (CypherParser::EscapedSymbolicName - 55)))) != 0))) {
- _errHandler->recoverInline(this);
- } else {
+ if (!(((((_la - 53) & ~ 0x3fULL) == 0) &&
+ ((1ULL << (_la - 53)) & ((1ULL << (CypherParser::HexLetter - 53))
+ | (1ULL << (CypherParser::UNION - 53))
+ | (1ULL << (CypherParser::ALL - 53))
+ | (1ULL << (CypherParser::OPTIONAL - 53))
+ | (1ULL << (CypherParser::MATCH - 53))
+ | (1ULL << (CypherParser::UNWIND - 53))
+ | (1ULL << (CypherParser::AS - 53))
+ | (1ULL << (CypherParser::MERGE - 53))
+ | (1ULL << (CypherParser::ON - 53))
+ | (1ULL << (CypherParser::CREATE - 53))
+ | (1ULL << (CypherParser::SET - 53))
+ | (1ULL << (CypherParser::DETACH - 53))
+ | (1ULL << (CypherParser::DELETE - 53))
+ | (1ULL << (CypherParser::REMOVE - 53))
+ | (1ULL << (CypherParser::WITH - 53))
+ | (1ULL << (CypherParser::DISTINCT - 53))
+ | (1ULL << (CypherParser::RETURN - 53))
+ | (1ULL << (CypherParser::ORDER - 53))
+ | (1ULL << (CypherParser::BY - 53))
+ | (1ULL << (CypherParser::L_SKIP - 53))
+ | (1ULL << (CypherParser::LIMIT - 53))
+ | (1ULL << (CypherParser::ASCENDING - 53))
+ | (1ULL << (CypherParser::ASC - 53))
+ | (1ULL << (CypherParser::DESCENDING - 53))
+ | (1ULL << (CypherParser::DESC - 53))
+ | (1ULL << (CypherParser::WHERE - 53))
+ | (1ULL << (CypherParser::OR - 53))
+ | (1ULL << (CypherParser::XOR - 53))
+ | (1ULL << (CypherParser::AND - 53))
+ | (1ULL << (CypherParser::NOT - 53))
+ | (1ULL << (CypherParser::IN - 53))
+ | (1ULL << (CypherParser::STARTS - 53))
+ | (1ULL << (CypherParser::ENDS - 53))
+ | (1ULL << (CypherParser::CONTAINS - 53))
+ | (1ULL << (CypherParser::IS - 53))
+ | (1ULL << (CypherParser::CYPHERNULL - 53))
+ | (1ULL << (CypherParser::COUNT - 53))
+ | (1ULL << (CypherParser::FILTER - 53))
+ | (1ULL << (CypherParser::EXTRACT - 53))
+ | (1ULL << (CypherParser::ANY - 53))
+ | (1ULL << (CypherParser::NONE - 53))
+ | (1ULL << (CypherParser::SINGLE - 53))
+ | (1ULL << (CypherParser::TRUE - 53))
+ | (1ULL << (CypherParser::FALSE - 53))
+ | (1ULL << (CypherParser::UnescapedSymbolicName - 53))
+ | (1ULL << (CypherParser::EscapedSymbolicName - 53)))) != 0))) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -8966,60 +9329,64 @@ CypherParser::SymbolicNameContext *CypherParser::symbolicName() {
return _localctx;
}
-//----------------- LeftArrowHeadContext
-//------------------------------------------------------------------
+//----------------- LeftArrowHeadContext ------------------------------------------------------------------
+
+CypherParser::LeftArrowHeadContext::LeftArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::LeftArrowHeadContext::LeftArrowHeadContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
size_t CypherParser::LeftArrowHeadContext::getRuleIndex() const {
return CypherParser::RuleLeftArrowHead;
}
-void CypherParser::LeftArrowHeadContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::LeftArrowHeadContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterLeftArrowHead(this);
+ if (parserListener != nullptr)
+ parserListener->enterLeftArrowHead(this);
}
-void CypherParser::LeftArrowHeadContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::LeftArrowHeadContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitLeftArrowHead(this);
+ if (parserListener != nullptr)
+ parserListener->exitLeftArrowHead(this);
}
-antlrcpp::Any CypherParser::LeftArrowHeadContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::LeftArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitLeftArrowHead(this);
else
return visitor->visitChildren(this);
}
-CypherParser::LeftArrowHeadContext *CypherParser::leftArrowHead() {
- LeftArrowHeadContext *_localctx =
- _tracker.createInstance<LeftArrowHeadContext>(_ctx, getState());
- enterRule(_localctx, 152, CypherParser::RuleLeftArrowHead);
+CypherParser::LeftArrowHeadContext* CypherParser::leftArrowHead() {
+ LeftArrowHeadContext *_localctx = _tracker.createInstance<LeftArrowHeadContext>(_ctx, getState());
+ enterRule(_localctx, 154, CypherParser::RuleLeftArrowHead);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1227);
+ setState(1305);
_la = _input->LA(1);
- if (!((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) &
- ((1ULL << CypherParser::T__21) | (1ULL << CypherParser::T__30) |
- (1ULL << CypherParser::T__31) | (1ULL << CypherParser::T__32) |
- (1ULL << CypherParser::T__33))) != 0))) {
- _errHandler->recoverInline(this);
- } else {
+ if (!((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::T__20)
+ | (1ULL << CypherParser::T__28)
+ | (1ULL << CypherParser::T__29)
+ | (1ULL << CypherParser::T__30)
+ | (1ULL << CypherParser::T__31))) != 0))) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -9028,60 +9395,64 @@ CypherParser::LeftArrowHeadContext *CypherParser::leftArrowHead() {
return _localctx;
}
-//----------------- RightArrowHeadContext
-//------------------------------------------------------------------
+//----------------- RightArrowHeadContext ------------------------------------------------------------------
+
+CypherParser::RightArrowHeadContext::RightArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::RightArrowHeadContext::RightArrowHeadContext(
- ParserRuleContext *parent, size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
size_t CypherParser::RightArrowHeadContext::getRuleIndex() const {
return CypherParser::RuleRightArrowHead;
}
-void CypherParser::RightArrowHeadContext::enterRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RightArrowHeadContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterRightArrowHead(this);
+ if (parserListener != nullptr)
+ parserListener->enterRightArrowHead(this);
}
-void CypherParser::RightArrowHeadContext::exitRule(
- tree::ParseTreeListener *listener) {
+void CypherParser::RightArrowHeadContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitRightArrowHead(this);
+ if (parserListener != nullptr)
+ parserListener->exitRightArrowHead(this);
}
-antlrcpp::Any CypherParser::RightArrowHeadContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::RightArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitRightArrowHead(this);
else
return visitor->visitChildren(this);
}
-CypherParser::RightArrowHeadContext *CypherParser::rightArrowHead() {
- RightArrowHeadContext *_localctx =
- _tracker.createInstance<RightArrowHeadContext>(_ctx, getState());
- enterRule(_localctx, 154, CypherParser::RuleRightArrowHead);
+CypherParser::RightArrowHeadContext* CypherParser::rightArrowHead() {
+ RightArrowHeadContext *_localctx = _tracker.createInstance<RightArrowHeadContext>(_ctx, getState());
+ enterRule(_localctx, 156, CypherParser::RuleRightArrowHead);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1229);
+ setState(1307);
_la = _input->LA(1);
- if (!((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) &
- ((1ULL << CypherParser::T__22) | (1ULL << CypherParser::T__34) |
- (1ULL << CypherParser::T__35) | (1ULL << CypherParser::T__36) |
- (1ULL << CypherParser::T__37))) != 0))) {
- _errHandler->recoverInline(this);
- } else {
+ if (!((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::T__21)
+ | (1ULL << CypherParser::T__32)
+ | (1ULL << CypherParser::T__33)
+ | (1ULL << CypherParser::T__34)
+ | (1ULL << CypherParser::T__35))) != 0))) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -9090,12 +9461,12 @@ CypherParser::RightArrowHeadContext *CypherParser::rightArrowHead() {
return _localctx;
}
-//----------------- DashContext
-//------------------------------------------------------------------
+//----------------- DashContext ------------------------------------------------------------------
+
+CypherParser::DashContext::DashContext(ParserRuleContext *parent, size_t invokingState)
+ : ParserRuleContext(parent, invokingState) {
+}
-CypherParser::DashContext::DashContext(ParserRuleContext *parent,
- size_t invokingState)
- : ParserRuleContext(parent, invokingState) {}
size_t CypherParser::DashContext::getRuleIndex() const {
return CypherParser::RuleDash;
@@ -9103,49 +9474,58 @@ size_t CypherParser::DashContext::getRuleIndex() const {
void CypherParser::DashContext::enterRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->enterDash(this);
+ if (parserListener != nullptr)
+ parserListener->enterDash(this);
}
void CypherParser::DashContext::exitRule(tree::ParseTreeListener *listener) {
auto parserListener = dynamic_cast<CypherListener *>(listener);
- if (parserListener != nullptr) parserListener->exitDash(this);
+ if (parserListener != nullptr)
+ parserListener->exitDash(this);
}
-antlrcpp::Any CypherParser::DashContext::accept(
- tree::ParseTreeVisitor *visitor) {
- if (auto parserVisitor = dynamic_cast<CypherVisitor *>(visitor))
+
+antlrcpp::Any CypherParser::DashContext::accept(tree::ParseTreeVisitor *visitor) {
+ if (auto parserVisitor = dynamic_cast<CypherVisitor*>(visitor))
return parserVisitor->visitDash(this);
else
return visitor->visitChildren(this);
}
-CypherParser::DashContext *CypherParser::dash() {
- DashContext *_localctx =
- _tracker.createInstance<DashContext>(_ctx, getState());
- enterRule(_localctx, 156, CypherParser::RuleDash);
+CypherParser::DashContext* CypherParser::dash() {
+ DashContext *_localctx = _tracker.createInstance<DashContext>(_ctx, getState());
+ enterRule(_localctx, 158, CypherParser::RuleDash);
size_t _la = 0;
- auto onExit = finally([=] { exitRule(); });
+ auto onExit = finally([=] {
+ exitRule();
+ });
try {
enterOuterAlt(_localctx, 1);
- setState(1231);
+ setState(1309);
_la = _input->LA(1);
- if (!((((_la & ~0x3fULL) == 0) &&
- ((1ULL << _la) &
- ((1ULL << CypherParser::T__14) | (1ULL << CypherParser::T__38) |
- (1ULL << CypherParser::T__39) | (1ULL << CypherParser::T__40) |
- (1ULL << CypherParser::T__41) | (1ULL << CypherParser::T__42) |
- (1ULL << CypherParser::T__43) | (1ULL << CypherParser::T__44) |
- (1ULL << CypherParser::T__45) | (1ULL << CypherParser::T__46) |
- (1ULL << CypherParser::T__47) | (1ULL << CypherParser::T__48))) !=
- 0))) {
- _errHandler->recoverInline(this);
- } else {
+ if (!((((_la & ~ 0x3fULL) == 0) &&
+ ((1ULL << _la) & ((1ULL << CypherParser::T__13)
+ | (1ULL << CypherParser::T__36)
+ | (1ULL << CypherParser::T__37)
+ | (1ULL << CypherParser::T__38)
+ | (1ULL << CypherParser::T__39)
+ | (1ULL << CypherParser::T__40)
+ | (1ULL << CypherParser::T__41)
+ | (1ULL << CypherParser::T__42)
+ | (1ULL << CypherParser::T__43)
+ | (1ULL << CypherParser::T__44)
+ | (1ULL << CypherParser::T__45)
+ | (1ULL << CypherParser::T__46))) != 0))) {
+ _errHandler->recoverInline(this);
+ }
+ else {
_errHandler->reportMatch(this);
consume();
}
-
- } catch (RecognitionException &e) {
+
+ }
+ catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
@@ -9163,1516 +9543,1075 @@ atn::ATN CypherParser::_atn;
std::vector<uint16_t> CypherParser::_serializedATN;
std::vector<std::string> CypherParser::_ruleNames = {
- "cypher",
- "statement",
- "query",
- "regularQuery",
- "singleQuery",
- "cypherUnion",
- "clause",
- "cypherMatch",
- "unwind",
- "merge",
- "mergeAction",
- "create",
- "set",
- "setItem",
- "cypherDelete",
- "remove",
- "removeItem",
- "with",
- "cypherReturn",
- "returnBody",
- "returnItems",
- "returnItem",
- "order",
- "skip",
- "limit",
- "sortItem",
- "where",
- "pattern",
- "patternPart",
- "anonymousPatternPart",
- "patternElement",
- "nodePattern",
- "patternElementChain",
- "relationshipPattern",
- "relationshipDetail",
- "properties",
- "relationshipTypes",
- "nodeLabels",
- "nodeLabel",
- "rangeLiteral",
- "labelName",
- "relTypeName",
- "expression",
- "expression12",
- "expression11",
- "expression10",
- "expression9",
- "expression8",
- "expression7",
- "expression6",
- "expression5",
- "expression4",
- "expression3",
- "expression2",
- "atom",
- "literal",
- "booleanLiteral",
- "listLiteral",
- "partialComparisonExpression",
- "parenthesizedExpression",
- "relationshipsPattern",
- "filterExpression",
- "idInColl",
- "functionInvocation",
- "functionName",
- "listComprehension",
- "propertyLookup",
- "variable",
- "numberLiteral",
- "mapLiteral",
- "parameter",
- "propertyExpression",
- "propertyKeyName",
- "integerLiteral",
- "doubleLiteral",
- "symbolicName",
- "leftArrowHead",
- "rightArrowHead",
- "dash"};
+ "cypher", "statement", "query", "regularQuery", "singleQuery", "cypherUnion",
+ "clause", "cypherMatch", "unwind", "merge", "mergeAction", "create", "set",
+ "setItem", "cypherDelete", "remove", "removeItem", "with", "cypherReturn",
+ "returnBody", "returnItems", "returnItem", "order", "skip", "limit", "sortItem",
+ "where", "pattern", "patternPart", "anonymousPatternPart", "patternElement",
+ "nodePattern", "patternElementChain", "relationshipPattern", "relationshipDetail",
+ "properties", "relationshipTypes", "nodeLabels", "nodeLabel", "rangeLiteral",
+ "labelName", "relTypeName", "expression", "expression12", "expression11",
+ "expression10", "expression9", "expression8", "expression7", "expression6",
+ "expression5", "expression4", "expression3", "expression2", "atom", "literal",
+ "booleanLiteral", "listLiteral", "partialComparisonExpression", "parenthesizedExpression",
+ "relationshipsPattern", "filterExpression", "idInColl", "functionInvocation",
+ "functionName", "listComprehension", "patternComprehension", "propertyLookup",
+ "variable", "numberLiteral", "mapLiteral", "parameter", "propertyExpression",
+ "propertyKeyName", "integerLiteral", "doubleLiteral", "symbolicName",
+ "leftArrowHead", "rightArrowHead", "dash"
+};
std::vector<std::string> CypherParser::_literalNames = {
- "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['",
- "'?'", "']'", "':'", "'|'", "'..'", "'+'", "'-'", "'/'", "'%'",
- "'^'", "'=~'", "'<>'", "'!='", "'<'", "'>'", "'<='", "'>='", "'.'",
- "'!'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", "'﹤'", "'＜'", "'⟩'",
- "'〉'", "'﹥'", "'＞'", "''", "'‐'", "'‑'", "'‒'", "'–'", "'—'",
- "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "",
- "", "", "", "", "", "", "", "'0'"};
+ "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'",
+ "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='",
+ "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'",
+ "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "''", "'‐'", "'‑'", "'‒'",
+ "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "",
+ "", "", "", "", "", "'0'"
+};
std::vector<std::string> CypherParser::_symbolicNames = {
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "",
- "StringLiteral",
- "EscapedChar",
- "HexInteger",
- "DecimalInteger",
- "OctalInteger",
- "HexLetter",
- "HexDigit",
- "Digit",
- "NonZeroDigit",
- "NonZeroOctDigit",
- "OctDigit",
- "ZeroDigit",
- "ExponentDecimalReal",
- "RegularDecimalReal",
- "UNION",
- "ALL",
- "OPTIONAL",
- "MATCH",
- "UNWIND",
- "AS",
- "MERGE",
- "ON",
- "CREATE",
- "SET",
- "DETACH",
- "DELETE",
- "REMOVE",
- "WITH",
- "DISTINCT",
- "RETURN",
- "ORDER",
- "BY",
- "L_SKIP",
- "LIMIT",
- "ASCENDING",
- "ASC",
- "DESCENDING",
- "DESC",
- "WHERE",
- "OR",
- "XOR",
- "AND",
- "NOT",
- "IN",
- "STARTS",
- "ENDS",
- "CONTAINS",
- "IS",
- "CYPHERNULL",
- "COUNT",
- "FILTER",
- "EXTRACT",
- "ANY",
- "NONE",
- "SINGLE",
- "TRUE",
- "FALSE",
- "UnescapedSymbolicName",
- "IdentifierStart",
- "IdentifierPart",
- "EscapedSymbolicName",
- "SP",
- "WHITESPACE",
- "Comment",
- "L_0X"};
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "", "", "", "", "", "StringLiteral", "EscapedChar",
+ "HexInteger", "DecimalInteger", "OctalInteger", "HexLetter", "HexDigit",
+ "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", "ZeroDigit", "ExponentDecimalReal",
+ "RegularDecimalReal", "UNION", "ALL", "OPTIONAL", "MATCH", "UNWIND", "AS",
+ "MERGE", "ON", "CREATE", "SET", "DETACH", "DELETE", "REMOVE", "WITH",
+ "DISTINCT", "RETURN", "ORDER", "BY", "L_SKIP", "LIMIT", "ASCENDING", "ASC",
+ "DESCENDING", "DESC", "WHERE", "OR", "XOR", "AND", "NOT", "IN", "STARTS",
+ "ENDS", "CONTAINS", "IS", "CYPHERNULL", "COUNT", "FILTER", "EXTRACT",
+ "ANY", "NONE", "SINGLE", "TRUE", "FALSE", "UnescapedSymbolicName", "IdentifierStart",
+ "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE", "Comment"
+};
dfa::Vocabulary CypherParser::_vocabulary(_literalNames, _symbolicNames);
std::vector<std::string> CypherParser::_tokenNames;
CypherParser::Initializer::Initializer() {
- for (size_t i = 0; i < _symbolicNames.size(); ++i) {
- std::string name = _vocabulary.getLiteralName(i);
- if (name.empty()) {
- name = _vocabulary.getSymbolicName(i);
- }
+ for (size_t i = 0; i < _symbolicNames.size(); ++i) {
+ std::string name = _vocabulary.getLiteralName(i);
+ if (name.empty()) {
+ name = _vocabulary.getSymbolicName(i);
+ }
- if (name.empty()) {
- _tokenNames.push_back("<INVALID>");
- } else {
+ if (name.empty()) {
+ _tokenNames.push_back("<INVALID>");
+ } else {
_tokenNames.push_back(name);
}
- }
+ }
_serializedATN = {
- 0x3, 0x430, 0xd6d1, 0x8206, 0xad2d, 0x4417, 0xaef1, 0x8d80, 0xaadd,
- 0x3, 0x74, 0x4d4, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3,
- 0x9, 0x3, 0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9,
- 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7,
- 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4,
- 0xa, 0x9, 0xa, 0x4, 0xb, 0x9, 0xb, 0x4, 0xc,
- 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9,
- 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10,
- 0x4, 0x11, 0x9, 0x11, 0x4, 0x12, 0x9, 0x12, 0x4,
- 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15,
- 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9,
- 0x17, 0x4, 0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19,
- 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4,
- 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e,
- 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9,
- 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22,
- 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4,
- 0x25, 0x9, 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27,
- 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, 0x9,
- 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b,
- 0x4, 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4,
- 0x2e, 0x9, 0x2e, 0x4, 0x2f, 0x9, 0x2f, 0x4, 0x30,
- 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9,
- 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34,
- 0x4, 0x35, 0x9, 0x35, 0x4, 0x36, 0x9, 0x36, 0x4,
- 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4, 0x39,
- 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9,
- 0x3b, 0x4, 0x3c, 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d,
- 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9, 0x3f, 0x4,
- 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42,
- 0x9, 0x42, 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9,
- 0x44, 0x4, 0x45, 0x9, 0x45, 0x4, 0x46, 0x9, 0x46,
- 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4,
- 0x49, 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b,
- 0x9, 0x4b, 0x4, 0x4c, 0x9, 0x4c, 0x4, 0x4d, 0x9,
- 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f,
- 0x4, 0x50, 0x9, 0x50, 0x3, 0x2, 0x5, 0x2, 0xa2,
- 0xa, 0x2, 0x3, 0x2, 0x3, 0x2, 0x5, 0x2, 0xa6,
- 0xa, 0x2, 0x3, 0x2, 0x5, 0x2, 0xa9, 0xa, 0x2,
- 0x3, 0x2, 0x5, 0x2, 0xac, 0xa, 0x2, 0x3, 0x3,
- 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3,
- 0x5, 0x5, 0x5, 0xb4, 0xa, 0x5, 0x3, 0x5, 0x7,
- 0x5, 0xb7, 0xa, 0x5, 0xc, 0x5, 0xe, 0x5, 0xba,
- 0xb, 0x5, 0x3, 0x6, 0x3, 0x6, 0x5, 0x6, 0xbe,
- 0xa, 0x6, 0x3, 0x6, 0x7, 0x6, 0xc1, 0xa, 0x6,
- 0xc, 0x6, 0xe, 0x6, 0xc4, 0xb, 0x6, 0x3, 0x7,
- 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x5, 0x7, 0xca,
- 0xa, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x5,
- 0x7, 0xcf, 0xa, 0x7, 0x3, 0x7, 0x5, 0x7, 0xd2,
- 0xa, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3,
- 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8,
- 0x3, 0x8, 0x5, 0x8, 0xdd, 0xa, 0x8, 0x3, 0x9,
- 0x3, 0x9, 0x5, 0x9, 0xe1, 0xa, 0x9, 0x3, 0x9,
- 0x3, 0x9, 0x5, 0x9, 0xe5, 0xa, 0x9, 0x3, 0x9,
- 0x3, 0x9, 0x5, 0x9, 0xe9, 0xa, 0x9, 0x3, 0x9,
- 0x5, 0x9, 0xec, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa,
- 0x5, 0xa, 0xf0, 0xa, 0xa, 0x3, 0xa, 0x3, 0xa,
- 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3,
- 0xb, 0x3, 0xb, 0x5, 0xb, 0xfa, 0xa, 0xb, 0x3,
- 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0xff, 0xa,
- 0xb, 0xc, 0xb, 0xe, 0xb, 0x102, 0xb, 0xb, 0x3,
- 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc,
- 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3,
- 0xc, 0x5, 0xc, 0x10e, 0xa, 0xc, 0x3, 0xd, 0x3,
- 0xd, 0x5, 0xd, 0x112, 0xa, 0xd, 0x3, 0xd, 0x3,
- 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe,
- 0x7, 0xe, 0x11a, 0xa, 0xe, 0xc, 0xe, 0xe, 0xe,
- 0x11d, 0xb, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf,
- 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3,
- 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf,
- 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x12e,
- 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x132,
- 0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x136,
- 0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x13a,
- 0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x13e,
- 0xa, 0x10, 0x3, 0x10, 0x7, 0x10, 0x141, 0xa, 0x10,
- 0xc, 0x10, 0xe, 0x10, 0x144, 0xb, 0x10, 0x3, 0x11,
- 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x14a,
- 0xa, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x14e,
- 0xa, 0x11, 0x3, 0x11, 0x7, 0x11, 0x151, 0xa, 0x11,
- 0xc, 0x11, 0xe, 0x11, 0x154, 0xb, 0x11, 0x3, 0x12,
- 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x15a,
- 0xa, 0x12, 0x3, 0x13, 0x3, 0x13, 0x5, 0x13, 0x15e,
- 0xa, 0x13, 0x3, 0x13, 0x5, 0x13, 0x161, 0xa, 0x13,
- 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x5, 0x13, 0x166,
- 0xa, 0x13, 0x3, 0x13, 0x5, 0x13, 0x169, 0xa, 0x13,
- 0x3, 0x14, 0x3, 0x14, 0x5, 0x14, 0x16d, 0xa, 0x14,
- 0x3, 0x14, 0x5, 0x14, 0x170, 0xa, 0x14, 0x3, 0x14,
- 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3,
- 0x15, 0x5, 0x15, 0x178, 0xa, 0x15, 0x3, 0x15, 0x3,
- 0x15, 0x5, 0x15, 0x17c, 0xa, 0x15, 0x3, 0x15, 0x3,
- 0x15, 0x5, 0x15, 0x180, 0xa, 0x15, 0x3, 0x16, 0x3,
- 0x16, 0x5, 0x16, 0x184, 0xa, 0x16, 0x3, 0x16, 0x3,
- 0x16, 0x5, 0x16, 0x188, 0xa, 0x16, 0x3, 0x16, 0x7,
- 0x16, 0x18b, 0xa, 0x16, 0xc, 0x16, 0xe, 0x16, 0x18e,
- 0xb, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16, 0x192,
- 0xa, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16, 0x196,
- 0xa, 0x16, 0x3, 0x16, 0x7, 0x16, 0x199, 0xa, 0x16,
- 0xc, 0x16, 0xe, 0x16, 0x19c, 0xb, 0x16, 0x5, 0x16,
- 0x19e, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17,
- 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x5,
- 0x17, 0x1a7, 0xa, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3,
- 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18,
- 0x5, 0x18, 0x1b0, 0xa, 0x18, 0x3, 0x18, 0x7, 0x18,
- 0x1b3, 0xa, 0x18, 0xc, 0x18, 0xe, 0x18, 0x1b6, 0xb,
- 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19,
- 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3,
- 0x1b, 0x3, 0x1b, 0x5, 0x1b, 0x1c2, 0xa, 0x1b, 0x3,
- 0x1b, 0x5, 0x1b, 0x1c5, 0xa, 0x1b, 0x3, 0x1c, 0x3,
- 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d,
- 0x5, 0x1d, 0x1cd, 0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d,
- 0x5, 0x1d, 0x1d1, 0xa, 0x1d, 0x3, 0x1d, 0x7, 0x1d,
- 0x1d4, 0xa, 0x1d, 0xc, 0x1d, 0xe, 0x1d, 0x1d7, 0xb,
- 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x1db, 0xa,
- 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x1df, 0xa,
- 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e,
- 0x1e4, 0xa, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20,
- 0x3, 0x20, 0x5, 0x20, 0x1ea, 0xa, 0x20, 0x3, 0x20,
- 0x7, 0x20, 0x1ed, 0xa, 0x20, 0xc, 0x20, 0xe, 0x20,
- 0x1f0, 0xb, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20,
- 0x3, 0x20, 0x5, 0x20, 0x1f6, 0xa, 0x20, 0x3, 0x21,
- 0x3, 0x21, 0x5, 0x21, 0x1fa, 0xa, 0x21, 0x3, 0x21,
- 0x3, 0x21, 0x5, 0x21, 0x1fe, 0xa, 0x21, 0x5, 0x21,
- 0x200, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x5, 0x21,
- 0x204, 0xa, 0x21, 0x5, 0x21, 0x206, 0xa, 0x21, 0x3,
- 0x21, 0x3, 0x21, 0x5, 0x21, 0x20a, 0xa, 0x21, 0x5,
- 0x21, 0x20c, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3,
- 0x22, 0x3, 0x22, 0x5, 0x22, 0x212, 0xa, 0x22, 0x3,
- 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x218, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x21c, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x21f, 0xa,
- 0x23, 0x3, 0x23, 0x5, 0x23, 0x222, 0xa, 0x23, 0x3,
- 0x23, 0x3, 0x23, 0x5, 0x23, 0x226, 0xa, 0x23, 0x3,
- 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x22c, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x230, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x233, 0xa,
- 0x23, 0x3, 0x23, 0x5, 0x23, 0x236, 0xa, 0x23, 0x3,
- 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x23c, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x23f, 0xa,
- 0x23, 0x3, 0x23, 0x5, 0x23, 0x242, 0xa, 0x23, 0x3,
- 0x23, 0x3, 0x23, 0x5, 0x23, 0x246, 0xa, 0x23, 0x3,
- 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
- 0x24c, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x24f, 0xa,
- 0x23, 0x3, 0x23, 0x5, 0x23, 0x252, 0xa, 0x23, 0x3,
- 0x23, 0x3, 0x23, 0x5, 0x23, 0x256, 0xa, 0x23, 0x3,
- 0x24, 0x3, 0x24, 0x5, 0x24, 0x25a, 0xa, 0x24, 0x3,
- 0x24, 0x5, 0x24, 0x25d, 0xa, 0x24, 0x3, 0x24, 0x5,
- 0x24, 0x260, 0xa, 0x24, 0x3, 0x24, 0x5, 0x24, 0x263,
- 0xa, 0x24, 0x3, 0x24, 0x5, 0x24, 0x266, 0xa, 0x24,
- 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x5,
- 0x25, 0x26c, 0xa, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3,
- 0x26, 0x5, 0x26, 0x271, 0xa, 0x26, 0x3, 0x26, 0x3,
- 0x26, 0x5, 0x26, 0x275, 0xa, 0x26, 0x3, 0x26, 0x5,
- 0x26, 0x278, 0xa, 0x26, 0x3, 0x26, 0x7, 0x26, 0x27b,
- 0xa, 0x26, 0xc, 0x26, 0xe, 0x26, 0x27e, 0xb, 0x26,
- 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x282, 0xa, 0x27,
- 0x3, 0x27, 0x7, 0x27, 0x285, 0xa, 0x27, 0xc, 0x27,
- 0xe, 0x27, 0x288, 0xb, 0x27, 0x3, 0x28, 0x3, 0x28,
- 0x3, 0x28, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x28f,
- 0xa, 0x29, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x293,
- 0xa, 0x29, 0x5, 0x29, 0x295, 0xa, 0x29, 0x3, 0x29,
- 0x3, 0x29, 0x5, 0x29, 0x299, 0xa, 0x29, 0x3, 0x29,
- 0x3, 0x29, 0x5, 0x29, 0x29d, 0xa, 0x29, 0x5, 0x29,
- 0x29f, 0xa, 0x29, 0x5, 0x29, 0x2a1, 0xa, 0x29, 0x3,
- 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c,
- 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3,
- 0x2d, 0x3, 0x2d, 0x7, 0x2d, 0x2ae, 0xa, 0x2d, 0xc,
- 0x2d, 0xe, 0x2d, 0x2b1, 0xb, 0x2d, 0x3, 0x2e, 0x3,
- 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x7, 0x2e,
- 0x2b8, 0xa, 0x2e, 0xc, 0x2e, 0xe, 0x2e, 0x2bb, 0xb,
- 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f,
- 0x3, 0x2f, 0x7, 0x2f, 0x2c2, 0xa, 0x2f, 0xc, 0x2f,
- 0xe, 0x2f, 0x2c5, 0xb, 0x2f, 0x3, 0x30, 0x3, 0x30,
- 0x5, 0x30, 0x2c9, 0xa, 0x30, 0x7, 0x30, 0x2cb, 0xa,
- 0x30, 0xc, 0x30, 0xe, 0x30, 0x2ce, 0xb, 0x30, 0x3,
- 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31,
- 0x2d4, 0xa, 0x31, 0x3, 0x31, 0x7, 0x31, 0x2d7, 0xa,
- 0x31, 0xc, 0x31, 0xe, 0x31, 0x2da, 0xb, 0x31, 0x3,
- 0x32, 0x3, 0x32, 0x5, 0x32, 0x2de, 0xa, 0x32, 0x3,
- 0x32, 0x3, 0x32, 0x5, 0x32, 0x2e2, 0xa, 0x32, 0x3,
- 0x32, 0x3, 0x32, 0x5, 0x32, 0x2e6, 0xa, 0x32, 0x3,
- 0x32, 0x3, 0x32, 0x5, 0x32, 0x2ea, 0xa, 0x32, 0x3,
- 0x32, 0x7, 0x32, 0x2ed, 0xa, 0x32, 0xc, 0x32, 0xe,
- 0x32, 0x2f0, 0xb, 0x32, 0x3, 0x33, 0x3, 0x33, 0x5,
- 0x33, 0x2f4, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5,
- 0x33, 0x2f8, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5,
- 0x33, 0x2fc, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5,
- 0x33, 0x300, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5,
- 0x33, 0x304, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5,
- 0x33, 0x308, 0xa, 0x33, 0x3, 0x33, 0x7, 0x33, 0x30b,
- 0xa, 0x33, 0xc, 0x33, 0xe, 0x33, 0x30e, 0xb, 0x33,
- 0x3, 0x34, 0x3, 0x34, 0x5, 0x34, 0x312, 0xa, 0x34,
- 0x3, 0x34, 0x3, 0x34, 0x5, 0x34, 0x316, 0xa, 0x34,
- 0x3, 0x34, 0x7, 0x34, 0x319, 0xa, 0x34, 0xc, 0x34,
- 0xe, 0x34, 0x31c, 0xb, 0x34, 0x3, 0x35, 0x3, 0x35,
- 0x5, 0x35, 0x320, 0xa, 0x35, 0x7, 0x35, 0x322, 0xa,
- 0x35, 0xc, 0x35, 0xe, 0x35, 0x325, 0xb, 0x35, 0x3,
- 0x35, 0x3, 0x35, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36,
- 0x32b, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x332, 0xa, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x336, 0xa, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x33a, 0xa, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x33e, 0xa, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3,
- 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5,
- 0x36, 0x34d, 0xa, 0x36, 0x3, 0x36, 0x5, 0x36, 0x350,
- 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3,
- 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
- 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x7, 0x36, 0x35d,
- 0xa, 0x36, 0xc, 0x36, 0xe, 0x36, 0x360, 0xb, 0x36,
- 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x7, 0x37, 0x365,
- 0xa, 0x37, 0xc, 0x37, 0xe, 0x37, 0x368, 0xb, 0x37,
- 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
- 0x38, 0x36e, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
- 0x38, 0x372, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
- 0x38, 0x376, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x5, 0x38, 0x37c, 0xa, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x5, 0x38, 0x380, 0xa, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x5, 0x38, 0x384, 0xa, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
- 0x38a, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
- 0x38e, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
- 0x392, 0xa, 0x38, 0x3, 0x38, 0x5, 0x38, 0x395, 0xa,
- 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x399, 0xa,
- 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x5, 0x38, 0x39f, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x5, 0x38, 0x3a3, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x5, 0x38, 0x3a7, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3ad, 0xa, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3b1, 0xa, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3b5, 0xa, 0x38,
- 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
- 0x38, 0x3bb, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
- 0x38, 0x3bf, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
- 0x38, 0x3c3, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x5, 0x38, 0x3c9, 0xa, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x5, 0x38, 0x3cd, 0xa, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x5, 0x38, 0x3d1, 0xa, 0x38, 0x3,
- 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
- 0x3, 0x38, 0x5, 0x38, 0x3d9, 0xa, 0x38, 0x3, 0x39,
- 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3,
- 0x39, 0x5, 0x39, 0x3e1, 0xa, 0x39, 0x3, 0x3a, 0x3,
- 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x3e7, 0xa,
- 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x3eb, 0xa,
- 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x3ef, 0xa,
- 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x3f3, 0xa,
- 0x3b, 0x7, 0x3b, 0x3f5, 0xa, 0x3b, 0xc, 0x3b, 0xe,
- 0x3b, 0x3f8, 0xb, 0x3b, 0x5, 0x3b, 0x3fa, 0xa, 0x3b,
- 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3c, 0x3, 0x3c, 0x5,
- 0x3c, 0x400, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3,
- 0x3c, 0x5, 0x3c, 0x405, 0xa, 0x3c, 0x3, 0x3c, 0x3,
- 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x40a, 0xa, 0x3c, 0x3,
- 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x40f, 0xa,
- 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c,
- 0x414, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c,
- 0x5, 0x3c, 0x419, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c,
- 0x3, 0x3c, 0x5, 0x3c, 0x41e, 0xa, 0x3c, 0x3, 0x3c,
- 0x5, 0x3c, 0x421, 0xa, 0x3c, 0x3, 0x3d, 0x3, 0x3d,
- 0x5, 0x3d, 0x425, 0xa, 0x3d, 0x3, 0x3d, 0x3, 0x3d,
- 0x5, 0x3d, 0x429, 0xa, 0x3d, 0x3, 0x3d, 0x3, 0x3d,
- 0x3, 0x3e, 0x3, 0x3e, 0x5, 0x3e, 0x42f, 0xa, 0x3e,
- 0x3, 0x3e, 0x6, 0x3e, 0x432, 0xa, 0x3e, 0xd, 0x3e,
- 0xe, 0x3e, 0x433, 0x3, 0x3f, 0x3, 0x3f, 0x5, 0x3f,
- 0x438, 0xa, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x43b, 0xa,
- 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40,
- 0x3, 0x40, 0x3, 0x40, 0x3, 0x41, 0x3, 0x41, 0x5,
- 0x41, 0x445, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5,
- 0x41, 0x449, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5,
- 0x41, 0x44d, 0xa, 0x41, 0x5, 0x41, 0x44f, 0xa, 0x41,
- 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x453, 0xa, 0x41,
- 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x457, 0xa, 0x41,
- 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x45b, 0xa, 0x41,
- 0x7, 0x41, 0x45d, 0xa, 0x41, 0xc, 0x41, 0xe, 0x41,
- 0x460, 0xb, 0x41, 0x5, 0x41, 0x462, 0xa, 0x41, 0x3,
- 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43,
- 0x3, 0x43, 0x5, 0x43, 0x46a, 0xa, 0x43, 0x3, 0x43,
- 0x3, 0x43, 0x5, 0x43, 0x46e, 0xa, 0x43, 0x3, 0x43,
- 0x3, 0x43, 0x5, 0x43, 0x472, 0xa, 0x43, 0x3, 0x43,
- 0x5, 0x43, 0x475, 0xa, 0x43, 0x3, 0x43, 0x5, 0x43,
- 0x478, 0xa, 0x43, 0x3, 0x43, 0x3, 0x43, 0x3, 0x44,
- 0x5, 0x44, 0x47d, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44,
- 0x5, 0x44, 0x481, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44,
- 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x487, 0xa, 0x44,
- 0x3, 0x45, 0x3, 0x45, 0x3, 0x46, 0x3, 0x46, 0x5,
- 0x46, 0x48d, 0xa, 0x46, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x491, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x495, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x499, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x49d, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x4a1, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x4a5, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x4a9, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x5,
- 0x47, 0x4ad, 0xa, 0x47, 0x7, 0x47, 0x4af, 0xa, 0x47,
- 0xc, 0x47, 0xe, 0x47, 0x4b2, 0xb, 0x47, 0x5, 0x47,
- 0x4b4, 0xa, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x48,
- 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4bb, 0xa, 0x48,
- 0x3, 0x49, 0x3, 0x49, 0x5, 0x49, 0x4bf, 0xa, 0x49,
- 0x3, 0x49, 0x6, 0x49, 0x4c2, 0xa, 0x49, 0xd, 0x49,
- 0xe, 0x49, 0x4c3, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b,
- 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3,
- 0x4d, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f, 0x3, 0x4f,
- 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x2, 0x2, 0x51,
- 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12,
- 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24,
- 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36,
- 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48,
- 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a,
- 0x5c, 0x5e, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c,
- 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e,
- 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90,
- 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0x2, 0xd,
- 0x3, 0x2, 0x56, 0x59, 0x3, 0x2, 0x10, 0x11, 0x3,
- 0x2, 0x6b, 0x6c, 0x5, 0x2, 0x65, 0x65, 0x6d, 0x6d,
- 0x70, 0x70, 0x4, 0x2, 0xb, 0xb, 0x1d, 0x1d, 0x3,
- 0x2, 0x36, 0x38, 0x3, 0x2, 0x40, 0x41, 0x5, 0x2,
- 0x39, 0x39, 0x42, 0x6d, 0x70, 0x70, 0x4, 0x2, 0x18,
- 0x18, 0x21, 0x24, 0x4, 0x2, 0x19, 0x19, 0x25, 0x28,
- 0x4, 0x2, 0x11, 0x11, 0x29, 0x33, 0x586, 0x2, 0xa1,
- 0x3, 0x2, 0x2, 0x2, 0x4, 0xad, 0x3, 0x2, 0x2,
- 0x2, 0x6, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x8, 0xb1,
- 0x3, 0x2, 0x2, 0x2, 0xa, 0xbb, 0x3, 0x2, 0x2,
- 0x2, 0xc, 0xd1, 0x3, 0x2, 0x2, 0x2, 0xe, 0xdc,
- 0x3, 0x2, 0x2, 0x2, 0x10, 0xe0, 0x3, 0x2, 0x2,
- 0x2, 0x12, 0xed, 0x3, 0x2, 0x2, 0x2, 0x14, 0xf7,
- 0x3, 0x2, 0x2, 0x2, 0x16, 0x10d, 0x3, 0x2, 0x2,
- 0x2, 0x18, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x115,
- 0x3, 0x2, 0x2, 0x2, 0x1c, 0x12d, 0x3, 0x2, 0x2,
- 0x2, 0x1e, 0x131, 0x3, 0x2, 0x2, 0x2, 0x20, 0x145,
- 0x3, 0x2, 0x2, 0x2, 0x22, 0x159, 0x3, 0x2, 0x2,
- 0x2, 0x24, 0x15b, 0x3, 0x2, 0x2, 0x2, 0x26, 0x16a,
- 0x3, 0x2, 0x2, 0x2, 0x28, 0x174, 0x3, 0x2, 0x2,
- 0x2, 0x2a, 0x19d, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x1a6,
- 0x3, 0x2, 0x2, 0x2, 0x2e, 0x1a8, 0x3, 0x2, 0x2,
- 0x2, 0x30, 0x1b7, 0x3, 0x2, 0x2, 0x2, 0x32, 0x1bb,
- 0x3, 0x2, 0x2, 0x2, 0x34, 0x1bf, 0x3, 0x2, 0x2,
- 0x2, 0x36, 0x1c6, 0x3, 0x2, 0x2, 0x2, 0x38, 0x1ca,
- 0x3, 0x2, 0x2, 0x2, 0x3a, 0x1e3, 0x3, 0x2, 0x2,
- 0x2, 0x3c, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x1f5,
- 0x3, 0x2, 0x2, 0x2, 0x40, 0x1f7, 0x3, 0x2, 0x2,
- 0x2, 0x42, 0x20f, 0x3, 0x2, 0x2, 0x2, 0x44, 0x255,
- 0x3, 0x2, 0x2, 0x2, 0x46, 0x257, 0x3, 0x2, 0x2,
- 0x2, 0x48, 0x26b, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x26d,
- 0x3, 0x2, 0x2, 0x2, 0x4c, 0x27f, 0x3, 0x2, 0x2,
- 0x2, 0x4e, 0x289, 0x3, 0x2, 0x2, 0x2, 0x50, 0x28c,
- 0x3, 0x2, 0x2, 0x2, 0x52, 0x2a2, 0x3, 0x2, 0x2,
- 0x2, 0x54, 0x2a4, 0x3, 0x2, 0x2, 0x2, 0x56, 0x2a6,
- 0x3, 0x2, 0x2, 0x2, 0x58, 0x2a8, 0x3, 0x2, 0x2,
- 0x2, 0x5a, 0x2b2, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x2bc,
- 0x3, 0x2, 0x2, 0x2, 0x5e, 0x2cc, 0x3, 0x2, 0x2,
- 0x2, 0x60, 0x2d1, 0x3, 0x2, 0x2, 0x2, 0x62, 0x2db,
- 0x3, 0x2, 0x2, 0x2, 0x64, 0x2f1, 0x3, 0x2, 0x2,
- 0x2, 0x66, 0x30f, 0x3, 0x2, 0x2, 0x2, 0x68, 0x323,
- 0x3, 0x2, 0x2, 0x2, 0x6a, 0x328, 0x3, 0x2, 0x2,
- 0x2, 0x6c, 0x361, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x3d8,
- 0x3, 0x2, 0x2, 0x2, 0x70, 0x3e0, 0x3, 0x2, 0x2,
- 0x2, 0x72, 0x3e2, 0x3, 0x2, 0x2, 0x2, 0x74, 0x3e4,
- 0x3, 0x2, 0x2, 0x2, 0x76, 0x420, 0x3, 0x2, 0x2,
- 0x2, 0x78, 0x422, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x42c,
- 0x3, 0x2, 0x2, 0x2, 0x7c, 0x435, 0x3, 0x2, 0x2,
- 0x2, 0x7e, 0x43c, 0x3, 0x2, 0x2, 0x2, 0x80, 0x442,
- 0x3, 0x2, 0x2, 0x2, 0x82, 0x465, 0x3, 0x2, 0x2,
- 0x2, 0x84, 0x467, 0x3, 0x2, 0x2, 0x2, 0x86, 0x47c,
- 0x3, 0x2, 0x2, 0x2, 0x88, 0x488, 0x3, 0x2, 0x2,
- 0x2, 0x8a, 0x48c, 0x3, 0x2, 0x2, 0x2, 0x8c, 0x48e,
- 0x3, 0x2, 0x2, 0x2, 0x8e, 0x4b7, 0x3, 0x2, 0x2,
- 0x2, 0x90, 0x4bc, 0x3, 0x2, 0x2, 0x2, 0x92, 0x4c5,
- 0x3, 0x2, 0x2, 0x2, 0x94, 0x4c7, 0x3, 0x2, 0x2,
- 0x2, 0x96, 0x4c9, 0x3, 0x2, 0x2, 0x2, 0x98, 0x4cb,
- 0x3, 0x2, 0x2, 0x2, 0x9a, 0x4cd, 0x3, 0x2, 0x2,
- 0x2, 0x9c, 0x4cf, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x4d1,
- 0x3, 0x2, 0x2, 0x2, 0xa0, 0xa2, 0x7, 0x71, 0x2,
- 0x2, 0xa1, 0xa0, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa2,
- 0x3, 0x2, 0x2, 0x2, 0xa2, 0xa3, 0x3, 0x2, 0x2,
- 0x2, 0xa3, 0xa8, 0x5, 0x4, 0x3, 0x2, 0xa4, 0xa6,
- 0x7, 0x71, 0x2, 0x2, 0xa5, 0xa4, 0x3, 0x2, 0x2,
- 0x2, 0xa5, 0xa6, 0x3, 0x2, 0x2, 0x2, 0xa6, 0xa7,
- 0x3, 0x2, 0x2, 0x2, 0xa7, 0xa9, 0x7, 0x3, 0x2,
- 0x2, 0xa8, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xa8, 0xa9,
- 0x3, 0x2, 0x2, 0x2, 0xa9, 0xab, 0x3, 0x2, 0x2,
- 0x2, 0xaa, 0xac, 0x7, 0x71, 0x2, 0x2, 0xab, 0xaa,
- 0x3, 0x2, 0x2, 0x2, 0xab, 0xac, 0x3, 0x2, 0x2,
- 0x2, 0xac, 0x3, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae,
- 0x5, 0x6, 0x4, 0x2, 0xae, 0x5, 0x3, 0x2, 0x2,
- 0x2, 0xaf, 0xb0, 0x5, 0x8, 0x5, 0x2, 0xb0, 0x7,
- 0x3, 0x2, 0x2, 0x2, 0xb1, 0xb8, 0x5, 0xa, 0x6,
- 0x2, 0xb2, 0xb4, 0x7, 0x71, 0x2, 0x2, 0xb3, 0xb2,
- 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb4, 0x3, 0x2, 0x2,
- 0x2, 0xb4, 0xb5, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb7,
- 0x5, 0xc, 0x7, 0x2, 0xb6, 0xb3, 0x3, 0x2, 0x2,
- 0x2, 0xb7, 0xba, 0x3, 0x2, 0x2, 0x2, 0xb8, 0xb6,
- 0x3, 0x2, 0x2, 0x2, 0xb8, 0xb9, 0x3, 0x2, 0x2,
- 0x2, 0xb9, 0x9, 0x3, 0x2, 0x2, 0x2, 0xba, 0xb8,
- 0x3, 0x2, 0x2, 0x2, 0xbb, 0xc2, 0x5, 0xe, 0x8,
- 0x2, 0xbc, 0xbe, 0x7, 0x71, 0x2, 0x2, 0xbd, 0xbc,
- 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbe, 0x3, 0x2, 0x2,
- 0x2, 0xbe, 0xbf, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc1,
- 0x5, 0xe, 0x8, 0x2, 0xc0, 0xbd, 0x3, 0x2, 0x2,
- 0x2, 0xc1, 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc2, 0xc0,
- 0x3, 0x2, 0x2, 0x2, 0xc2, 0xc3, 0x3, 0x2, 0x2,
- 0x2, 0xc3, 0xb, 0x3, 0x2, 0x2, 0x2, 0xc4, 0xc2,
- 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc6, 0x7, 0x42, 0x2,
- 0x2, 0xc6, 0xc7, 0x7, 0x71, 0x2, 0x2, 0xc7, 0xc9,
- 0x7, 0x43, 0x2, 0x2, 0xc8, 0xca, 0x7, 0x71, 0x2,
- 0x2, 0xc9, 0xc8, 0x3, 0x2, 0x2, 0x2, 0xc9, 0xca,
- 0x3, 0x2, 0x2, 0x2, 0xca, 0xcb, 0x3, 0x2, 0x2,
- 0x2, 0xcb, 0xd2, 0x5, 0xa, 0x6, 0x2, 0xcc, 0xce,
- 0x7, 0x42, 0x2, 0x2, 0xcd, 0xcf, 0x7, 0x71, 0x2,
- 0x2, 0xce, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcf,
- 0x3, 0x2, 0x2, 0x2, 0xcf, 0xd0, 0x3, 0x2, 0x2,
- 0x2, 0xd0, 0xd2, 0x5, 0xa, 0x6, 0x2, 0xd1, 0xc5,
- 0x3, 0x2, 0x2, 0x2, 0xd1, 0xcc, 0x3, 0x2, 0x2,
- 0x2, 0xd2, 0xd, 0x3, 0x2, 0x2, 0x2, 0xd3, 0xdd,
- 0x5, 0x10, 0x9, 0x2, 0xd4, 0xdd, 0x5, 0x12, 0xa,
- 0x2, 0xd5, 0xdd, 0x5, 0x14, 0xb, 0x2, 0xd6, 0xdd,
- 0x5, 0x18, 0xd, 0x2, 0xd7, 0xdd, 0x5, 0x1a, 0xe,
- 0x2, 0xd8, 0xdd, 0x5, 0x1e, 0x10, 0x2, 0xd9, 0xdd,
- 0x5, 0x20, 0x11, 0x2, 0xda, 0xdd, 0x5, 0x24, 0x13,
- 0x2, 0xdb, 0xdd, 0x5, 0x26, 0x14, 0x2, 0xdc, 0xd3,
- 0x3, 0x2, 0x2, 0x2, 0xdc, 0xd4, 0x3, 0x2, 0x2,
- 0x2, 0xdc, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xd6,
- 0x3, 0x2, 0x2, 0x2, 0xdc, 0xd7, 0x3, 0x2, 0x2,
- 0x2, 0xdc, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xd9,
- 0x3, 0x2, 0x2, 0x2, 0xdc, 0xda, 0x3, 0x2, 0x2,
- 0x2, 0xdc, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xdd, 0xf,
- 0x3, 0x2, 0x2, 0x2, 0xde, 0xdf, 0x7, 0x44, 0x2,
- 0x2, 0xdf, 0xe1, 0x7, 0x71, 0x2, 0x2, 0xe0, 0xde,
- 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x3, 0x2, 0x2,
- 0x2, 0xe1, 0xe2, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe4,
- 0x7, 0x45, 0x2, 0x2, 0xe3, 0xe5, 0x7, 0x71, 0x2,
- 0x2, 0xe4, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5,
- 0x3, 0x2, 0x2, 0x2, 0xe5, 0xe6, 0x3, 0x2, 0x2,
- 0x2, 0xe6, 0xeb, 0x5, 0x38, 0x1d, 0x2, 0xe7, 0xe9,
- 0x7, 0x71, 0x2, 0x2, 0xe8, 0xe7, 0x3, 0x2, 0x2,
- 0x2, 0xe8, 0xe9, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xea,
- 0x3, 0x2, 0x2, 0x2, 0xea, 0xec, 0x5, 0x36, 0x1c,
- 0x2, 0xeb, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xec,
- 0x3, 0x2, 0x2, 0x2, 0xec, 0x11, 0x3, 0x2, 0x2,
- 0x2, 0xed, 0xef, 0x7, 0x46, 0x2, 0x2, 0xee, 0xf0,
- 0x7, 0x71, 0x2, 0x2, 0xef, 0xee, 0x3, 0x2, 0x2,
- 0x2, 0xef, 0xf0, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf1,
- 0x3, 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x5, 0x56, 0x2c,
- 0x2, 0xf2, 0xf3, 0x7, 0x71, 0x2, 0x2, 0xf3, 0xf4,
- 0x7, 0x47, 0x2, 0x2, 0xf4, 0xf5, 0x7, 0x71, 0x2,
- 0x2, 0xf5, 0xf6, 0x5, 0x88, 0x45, 0x2, 0xf6, 0x13,
- 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf9, 0x7, 0x48, 0x2,
- 0x2, 0xf8, 0xfa, 0x7, 0x71, 0x2, 0x2, 0xf9, 0xf8,
- 0x3, 0x2, 0x2, 0x2, 0xf9, 0xfa, 0x3, 0x2, 0x2,
- 0x2, 0xfa, 0xfb, 0x3, 0x2, 0x2, 0x2, 0xfb, 0x100,
- 0x5, 0x3a, 0x1e, 0x2, 0xfc, 0xfd, 0x7, 0x71, 0x2,
- 0x2, 0xfd, 0xff, 0x5, 0x16, 0xc, 0x2, 0xfe, 0xfc,
- 0x3, 0x2, 0x2, 0x2, 0xff, 0x102, 0x3, 0x2, 0x2,
- 0x2, 0x100, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x100, 0x101,
- 0x3, 0x2, 0x2, 0x2, 0x101, 0x15, 0x3, 0x2, 0x2,
- 0x2, 0x102, 0x100, 0x3, 0x2, 0x2, 0x2, 0x103, 0x104,
- 0x7, 0x49, 0x2, 0x2, 0x104, 0x105, 0x7, 0x71, 0x2,
- 0x2, 0x105, 0x106, 0x7, 0x45, 0x2, 0x2, 0x106, 0x107,
- 0x7, 0x71, 0x2, 0x2, 0x107, 0x10e, 0x5, 0x1a, 0xe,
- 0x2, 0x108, 0x109, 0x7, 0x49, 0x2, 0x2, 0x109, 0x10a,
- 0x7, 0x71, 0x2, 0x2, 0x10a, 0x10b, 0x7, 0x4a, 0x2,
- 0x2, 0x10b, 0x10c, 0x7, 0x71, 0x2, 0x2, 0x10c, 0x10e,
- 0x5, 0x1a, 0xe, 0x2, 0x10d, 0x103, 0x3, 0x2, 0x2,
- 0x2, 0x10d, 0x108, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x17,
- 0x3, 0x2, 0x2, 0x2, 0x10f, 0x111, 0x7, 0x4a, 0x2,
- 0x2, 0x110, 0x112, 0x7, 0x71, 0x2, 0x2, 0x111, 0x110,
- 0x3, 0x2, 0x2, 0x2, 0x111, 0x112, 0x3, 0x2, 0x2,
- 0x2, 0x112, 0x113, 0x3, 0x2, 0x2, 0x2, 0x113, 0x114,
- 0x5, 0x38, 0x1d, 0x2, 0x114, 0x19, 0x3, 0x2, 0x2,
- 0x2, 0x115, 0x116, 0x7, 0x4b, 0x2, 0x2, 0x116, 0x11b,
- 0x5, 0x1c, 0xf, 0x2, 0x117, 0x118, 0x7, 0x4, 0x2,
- 0x2, 0x118, 0x11a, 0x5, 0x1c, 0xf, 0x2, 0x119, 0x117,
- 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11d, 0x3, 0x2, 0x2,
- 0x2, 0x11b, 0x119, 0x3, 0x2, 0x2, 0x2, 0x11b, 0x11c,
- 0x3, 0x2, 0x2, 0x2, 0x11c, 0x1b, 0x3, 0x2, 0x2,
- 0x2, 0x11d, 0x11b, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x11f,
- 0x5, 0x90, 0x49, 0x2, 0x11f, 0x120, 0x7, 0x5, 0x2,
- 0x2, 0x120, 0x121, 0x5, 0x56, 0x2c, 0x2, 0x121, 0x12e,
- 0x3, 0x2, 0x2, 0x2, 0x122, 0x123, 0x5, 0x88, 0x45,
- 0x2, 0x123, 0x124, 0x7, 0x5, 0x2, 0x2, 0x124, 0x125,
- 0x5, 0x56, 0x2c, 0x2, 0x125, 0x12e, 0x3, 0x2, 0x2,
- 0x2, 0x126, 0x127, 0x5, 0x88, 0x45, 0x2, 0x127, 0x128,
- 0x7, 0x6, 0x2, 0x2, 0x128, 0x129, 0x5, 0x56, 0x2c,
- 0x2, 0x129, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x12b,
- 0x5, 0x88, 0x45, 0x2, 0x12b, 0x12c, 0x5, 0x4c, 0x27,
- 0x2, 0x12c, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x11e,
- 0x3, 0x2, 0x2, 0x2, 0x12d, 0x122, 0x3, 0x2, 0x2,
- 0x2, 0x12d, 0x126, 0x3, 0x2, 0x2, 0x2, 0x12d, 0x12a,
- 0x3, 0x2, 0x2, 0x2, 0x12e, 0x1d, 0x3, 0x2, 0x2,
- 0x2, 0x12f, 0x130, 0x7, 0x4c, 0x2, 0x2, 0x130, 0x132,
- 0x7, 0x71, 0x2, 0x2, 0x131, 0x12f, 0x3, 0x2, 0x2,
- 0x2, 0x131, 0x132, 0x3, 0x2, 0x2, 0x2, 0x132, 0x133,
- 0x3, 0x2, 0x2, 0x2, 0x133, 0x135, 0x7, 0x4d, 0x2,
- 0x2, 0x134, 0x136, 0x7, 0x71, 0x2, 0x2, 0x135, 0x134,
- 0x3, 0x2, 0x2, 0x2, 0x135, 0x136, 0x3, 0x2, 0x2,
- 0x2, 0x136, 0x137, 0x3, 0x2, 0x2, 0x2, 0x137, 0x142,
- 0x5, 0x56, 0x2c, 0x2, 0x138, 0x13a, 0x7, 0x71, 0x2,
- 0x2, 0x139, 0x138, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13a,
- 0x3, 0x2, 0x2, 0x2, 0x13a, 0x13b, 0x3, 0x2, 0x2,
- 0x2, 0x13b, 0x13d, 0x7, 0x4, 0x2, 0x2, 0x13c, 0x13e,
- 0x7, 0x71, 0x2, 0x2, 0x13d, 0x13c, 0x3, 0x2, 0x2,
- 0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13f,
- 0x3, 0x2, 0x2, 0x2, 0x13f, 0x141, 0x5, 0x56, 0x2c,
- 0x2, 0x140, 0x139, 0x3, 0x2, 0x2, 0x2, 0x141, 0x144,
- 0x3, 0x2, 0x2, 0x2, 0x142, 0x140, 0x3, 0x2, 0x2,
- 0x2, 0x142, 0x143, 0x3, 0x2, 0x2, 0x2, 0x143, 0x1f,
- 0x3, 0x2, 0x2, 0x2, 0x144, 0x142, 0x3, 0x2, 0x2,
- 0x2, 0x145, 0x146, 0x7, 0x4e, 0x2, 0x2, 0x146, 0x147,
- 0x7, 0x71, 0x2, 0x2, 0x147, 0x152, 0x5, 0x22, 0x12,
- 0x2, 0x148, 0x14a, 0x7, 0x71, 0x2, 0x2, 0x149, 0x148,
- 0x3, 0x2, 0x2, 0x2, 0x149, 0x14a, 0x3, 0x2, 0x2,
- 0x2, 0x14a, 0x14b, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x14d,
- 0x7, 0x4, 0x2, 0x2, 0x14c, 0x14e, 0x7, 0x71, 0x2,
- 0x2, 0x14d, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x14d, 0x14e,
- 0x3, 0x2, 0x2, 0x2, 0x14e, 0x14f, 0x3, 0x2, 0x2,
- 0x2, 0x14f, 0x151, 0x5, 0x22, 0x12, 0x2, 0x150, 0x149,
- 0x3, 0x2, 0x2, 0x2, 0x151, 0x154, 0x3, 0x2, 0x2,
- 0x2, 0x152, 0x150, 0x3, 0x2, 0x2, 0x2, 0x152, 0x153,
- 0x3, 0x2, 0x2, 0x2, 0x153, 0x21, 0x3, 0x2, 0x2,
- 0x2, 0x154, 0x152, 0x3, 0x2, 0x2, 0x2, 0x155, 0x156,
- 0x5, 0x88, 0x45, 0x2, 0x156, 0x157, 0x5, 0x4c, 0x27,
- 0x2, 0x157, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x158, 0x15a,
- 0x5, 0x90, 0x49, 0x2, 0x159, 0x155, 0x3, 0x2, 0x2,
- 0x2, 0x159, 0x158, 0x3, 0x2, 0x2, 0x2, 0x15a, 0x23,
- 0x3, 0x2, 0x2, 0x2, 0x15b, 0x160, 0x7, 0x4f, 0x2,
- 0x2, 0x15c, 0x15e, 0x7, 0x71, 0x2, 0x2, 0x15d, 0x15c,
- 0x3, 0x2, 0x2, 0x2, 0x15d, 0x15e, 0x3, 0x2, 0x2,
- 0x2, 0x15e, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x15f, 0x161,
- 0x7, 0x50, 0x2, 0x2, 0x160, 0x15d, 0x3, 0x2, 0x2,
- 0x2, 0x160, 0x161, 0x3, 0x2, 0x2, 0x2, 0x161, 0x162,
- 0x3, 0x2, 0x2, 0x2, 0x162, 0x163, 0x7, 0x71, 0x2,
- 0x2, 0x163, 0x168, 0x5, 0x28, 0x15, 0x2, 0x164, 0x166,
- 0x7, 0x71, 0x2, 0x2, 0x165, 0x164, 0x3, 0x2, 0x2,
- 0x2, 0x165, 0x166, 0x3, 0x2, 0x2, 0x2, 0x166, 0x167,
- 0x3, 0x2, 0x2, 0x2, 0x167, 0x169, 0x5, 0x36, 0x1c,
- 0x2, 0x168, 0x165, 0x3, 0x2, 0x2, 0x2, 0x168, 0x169,
- 0x3, 0x2, 0x2, 0x2, 0x169, 0x25, 0x3, 0x2, 0x2,
- 0x2, 0x16a, 0x16f, 0x7, 0x51, 0x2, 0x2, 0x16b, 0x16d,
- 0x7, 0x71, 0x2, 0x2, 0x16c, 0x16b, 0x3, 0x2, 0x2,
- 0x2, 0x16c, 0x16d, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16e,
- 0x3, 0x2, 0x2, 0x2, 0x16e, 0x170, 0x7, 0x50, 0x2,
- 0x2, 0x16f, 0x16c, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x170,
- 0x3, 0x2, 0x2, 0x2, 0x170, 0x171, 0x3, 0x2, 0x2,
- 0x2, 0x171, 0x172, 0x7, 0x71, 0x2, 0x2, 0x172, 0x173,
- 0x5, 0x28, 0x15, 0x2, 0x173, 0x27, 0x3, 0x2, 0x2,
- 0x2, 0x174, 0x177, 0x5, 0x2a, 0x16, 0x2, 0x175, 0x176,
- 0x7, 0x71, 0x2, 0x2, 0x176, 0x178, 0x5, 0x2e, 0x18,
- 0x2, 0x177, 0x175, 0x3, 0x2, 0x2, 0x2, 0x177, 0x178,
- 0x3, 0x2, 0x2, 0x2, 0x178, 0x17b, 0x3, 0x2, 0x2,
- 0x2, 0x179, 0x17a, 0x7, 0x71, 0x2, 0x2, 0x17a, 0x17c,
- 0x5, 0x30, 0x19, 0x2, 0x17b, 0x179, 0x3, 0x2, 0x2,
- 0x2, 0x17b, 0x17c, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x17f,
- 0x3, 0x2, 0x2, 0x2, 0x17d, 0x17e, 0x7, 0x71, 0x2,
- 0x2, 0x17e, 0x180, 0x5, 0x32, 0x1a, 0x2, 0x17f, 0x17d,
- 0x3, 0x2, 0x2, 0x2, 0x17f, 0x180, 0x3, 0x2, 0x2,
- 0x2, 0x180, 0x29, 0x3, 0x2, 0x2, 0x2, 0x181, 0x18c,
- 0x7, 0x7, 0x2, 0x2, 0x182, 0x184, 0x7, 0x71, 0x2,
- 0x2, 0x183, 0x182, 0x3, 0x2, 0x2, 0x2, 0x183, 0x184,
- 0x3, 0x2, 0x2, 0x2, 0x184, 0x185, 0x3, 0x2, 0x2,
- 0x2, 0x185, 0x187, 0x7, 0x4, 0x2, 0x2, 0x186, 0x188,
- 0x7, 0x71, 0x2, 0x2, 0x187, 0x186, 0x3, 0x2, 0x2,
- 0x2, 0x187, 0x188, 0x3, 0x2, 0x2, 0x2, 0x188, 0x189,
- 0x3, 0x2, 0x2, 0x2, 0x189, 0x18b, 0x5, 0x2c, 0x17,
- 0x2, 0x18a, 0x183, 0x3, 0x2, 0x2, 0x2, 0x18b, 0x18e,
- 0x3, 0x2, 0x2, 0x2, 0x18c, 0x18a, 0x3, 0x2, 0x2,
- 0x2, 0x18c, 0x18d, 0x3, 0x2, 0x2, 0x2, 0x18d, 0x19e,
- 0x3, 0x2, 0x2, 0x2, 0x18e, 0x18c, 0x3, 0x2, 0x2,
- 0x2, 0x18f, 0x19a, 0x5, 0x2c, 0x17, 0x2, 0x190, 0x192,
- 0x7, 0x71, 0x2, 0x2, 0x191, 0x190, 0x3, 0x2, 0x2,
- 0x2, 0x191, 0x192, 0x3, 0x2, 0x2, 0x2, 0x192, 0x193,
- 0x3, 0x2, 0x2, 0x2, 0x193, 0x195, 0x7, 0x4, 0x2,
- 0x2, 0x194, 0x196, 0x7, 0x71, 0x2, 0x2, 0x195, 0x194,
- 0x3, 0x2, 0x2, 0x2, 0x195, 0x196, 0x3, 0x2, 0x2,
- 0x2, 0x196, 0x197, 0x3, 0x2, 0x2, 0x2, 0x197, 0x199,
- 0x5, 0x2c, 0x17, 0x2, 0x198, 0x191, 0x3, 0x2, 0x2,
- 0x2, 0x199, 0x19c, 0x3, 0x2, 0x2, 0x2, 0x19a, 0x198,
- 0x3, 0x2, 0x2, 0x2, 0x19a, 0x19b, 0x3, 0x2, 0x2,
- 0x2, 0x19b, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x19c, 0x19a,
- 0x3, 0x2, 0x2, 0x2, 0x19d, 0x181, 0x3, 0x2, 0x2,
- 0x2, 0x19d, 0x18f, 0x3, 0x2, 0x2, 0x2, 0x19e, 0x2b,
- 0x3, 0x2, 0x2, 0x2, 0x19f, 0x1a0, 0x5, 0x56, 0x2c,
- 0x2, 0x1a0, 0x1a1, 0x7, 0x71, 0x2, 0x2, 0x1a1, 0x1a2,
- 0x7, 0x47, 0x2, 0x2, 0x1a2, 0x1a3, 0x7, 0x71, 0x2,
- 0x2, 0x1a3, 0x1a4, 0x5, 0x88, 0x45, 0x2, 0x1a4, 0x1a7,
- 0x3, 0x2, 0x2, 0x2, 0x1a5, 0x1a7, 0x5, 0x56, 0x2c,
- 0x2, 0x1a6, 0x19f, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1a5,
- 0x3, 0x2, 0x2, 0x2, 0x1a7, 0x2d, 0x3, 0x2, 0x2,
- 0x2, 0x1a8, 0x1a9, 0x7, 0x52, 0x2, 0x2, 0x1a9, 0x1aa,
- 0x7, 0x71, 0x2, 0x2, 0x1aa, 0x1ab, 0x7, 0x53, 0x2,
- 0x2, 0x1ab, 0x1ac, 0x7, 0x71, 0x2, 0x2, 0x1ac, 0x1b4,
- 0x5, 0x34, 0x1b, 0x2, 0x1ad, 0x1af, 0x7, 0x4, 0x2,
- 0x2, 0x1ae, 0x1b0, 0x7, 0x71, 0x2, 0x2, 0x1af, 0x1ae,
- 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b0, 0x3, 0x2, 0x2,
- 0x2, 0x1b0, 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x1b1, 0x1b3,
- 0x5, 0x34, 0x1b, 0x2, 0x1b2, 0x1ad, 0x3, 0x2, 0x2,
- 0x2, 0x1b3, 0x1b6, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b2,
- 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b5, 0x3, 0x2, 0x2,
- 0x2, 0x1b5, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x1b6, 0x1b4,
- 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1b8, 0x7, 0x54, 0x2,
- 0x2, 0x1b8, 0x1b9, 0x7, 0x71, 0x2, 0x2, 0x1b9, 0x1ba,
- 0x5, 0x56, 0x2c, 0x2, 0x1ba, 0x31, 0x3, 0x2, 0x2,
- 0x2, 0x1bb, 0x1bc, 0x7, 0x55, 0x2, 0x2, 0x1bc, 0x1bd,
- 0x7, 0x71, 0x2, 0x2, 0x1bd, 0x1be, 0x5, 0x56, 0x2c,
- 0x2, 0x1be, 0x33, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1c4,
- 0x5, 0x56, 0x2c, 0x2, 0x1c0, 0x1c2, 0x7, 0x71, 0x2,
- 0x2, 0x1c1, 0x1c0, 0x3, 0x2, 0x2, 0x2, 0x1c1, 0x1c2,
- 0x3, 0x2, 0x2, 0x2, 0x1c2, 0x1c3, 0x3, 0x2, 0x2,
- 0x2, 0x1c3, 0x1c5, 0x9, 0x2, 0x2, 0x2, 0x1c4, 0x1c1,
- 0x3, 0x2, 0x2, 0x2, 0x1c4, 0x1c5, 0x3, 0x2, 0x2,
- 0x2, 0x1c5, 0x35, 0x3, 0x2, 0x2, 0x2, 0x1c6, 0x1c7,
- 0x7, 0x5a, 0x2, 0x2, 0x1c7, 0x1c8, 0x7, 0x71, 0x2,
- 0x2, 0x1c8, 0x1c9, 0x5, 0x56, 0x2c, 0x2, 0x1c9, 0x37,
- 0x3, 0x2, 0x2, 0x2, 0x1ca, 0x1d5, 0x5, 0x3a, 0x1e,
- 0x2, 0x1cb, 0x1cd, 0x7, 0x71, 0x2, 0x2, 0x1cc, 0x1cb,
- 0x3, 0x2, 0x2, 0x2, 0x1cc, 0x1cd, 0x3, 0x2, 0x2,
- 0x2, 0x1cd, 0x1ce, 0x3, 0x2, 0x2, 0x2, 0x1ce, 0x1d0,
- 0x7, 0x4, 0x2, 0x2, 0x1cf, 0x1d1, 0x7, 0x71, 0x2,
- 0x2, 0x1d0, 0x1cf, 0x3, 0x2, 0x2, 0x2, 0x1d0, 0x1d1,
- 0x3, 0x2, 0x2, 0x2, 0x1d1, 0x1d2, 0x3, 0x2, 0x2,
- 0x2, 0x1d2, 0x1d4, 0x5, 0x3a, 0x1e, 0x2, 0x1d3, 0x1cc,
- 0x3, 0x2, 0x2, 0x2, 0x1d4, 0x1d7, 0x3, 0x2, 0x2,
- 0x2, 0x1d5, 0x1d3, 0x3, 0x2, 0x2, 0x2, 0x1d5, 0x1d6,
- 0x3, 0x2, 0x2, 0x2, 0x1d6, 0x39, 0x3, 0x2, 0x2,
- 0x2, 0x1d7, 0x1d5, 0x3, 0x2, 0x2, 0x2, 0x1d8, 0x1da,
- 0x5, 0x88, 0x45, 0x2, 0x1d9, 0x1db, 0x7, 0x71, 0x2,
- 0x2, 0x1da, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x1da, 0x1db,
- 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dc, 0x3, 0x2, 0x2,
- 0x2, 0x1dc, 0x1de, 0x7, 0x5, 0x2, 0x2, 0x1dd, 0x1df,
- 0x7, 0x71, 0x2, 0x2, 0x1de, 0x1dd, 0x3, 0x2, 0x2,
- 0x2, 0x1de, 0x1df, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1e0,
- 0x3, 0x2, 0x2, 0x2, 0x1e0, 0x1e1, 0x5, 0x3c, 0x1f,
- 0x2, 0x1e1, 0x1e4, 0x3, 0x2, 0x2, 0x2, 0x1e2, 0x1e4,
- 0x5, 0x3c, 0x1f, 0x2, 0x1e3, 0x1d8, 0x3, 0x2, 0x2,
- 0x2, 0x1e3, 0x1e2, 0x3, 0x2, 0x2, 0x2, 0x1e4, 0x3b,
- 0x3, 0x2, 0x2, 0x2, 0x1e5, 0x1e6, 0x5, 0x3e, 0x20,
- 0x2, 0x1e6, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x1e7, 0x1ee,
- 0x5, 0x40, 0x21, 0x2, 0x1e8, 0x1ea, 0x7, 0x71, 0x2,
- 0x2, 0x1e9, 0x1e8, 0x3, 0x2, 0x2, 0x2, 0x1e9, 0x1ea,
- 0x3, 0x2, 0x2, 0x2, 0x1ea, 0x1eb, 0x3, 0x2, 0x2,
- 0x2, 0x1eb, 0x1ed, 0x5, 0x42, 0x22, 0x2, 0x1ec, 0x1e9,
- 0x3, 0x2, 0x2, 0x2, 0x1ed, 0x1f0, 0x3, 0x2, 0x2,
- 0x2, 0x1ee, 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x1ee, 0x1ef,
- 0x3, 0x2, 0x2, 0x2, 0x1ef, 0x1f6, 0x3, 0x2, 0x2,
- 0x2, 0x1f0, 0x1ee, 0x3, 0x2, 0x2, 0x2, 0x1f1, 0x1f2,
- 0x7, 0x8, 0x2, 0x2, 0x1f2, 0x1f3, 0x5, 0x3e, 0x20,
- 0x2, 0x1f3, 0x1f4, 0x7, 0x9, 0x2, 0x2, 0x1f4, 0x1f6,
- 0x3, 0x2, 0x2, 0x2, 0x1f5, 0x1e7, 0x3, 0x2, 0x2,
- 0x2, 0x1f5, 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x1f6, 0x3f,
- 0x3, 0x2, 0x2, 0x2, 0x1f7, 0x1f9, 0x7, 0x8, 0x2,
- 0x2, 0x1f8, 0x1fa, 0x7, 0x71, 0x2, 0x2, 0x1f9, 0x1f8,
- 0x3, 0x2, 0x2, 0x2, 0x1f9, 0x1fa, 0x3, 0x2, 0x2,
- 0x2, 0x1fa, 0x1ff, 0x3, 0x2, 0x2, 0x2, 0x1fb, 0x1fd,
- 0x5, 0x88, 0x45, 0x2, 0x1fc, 0x1fe, 0x7, 0x71, 0x2,
- 0x2, 0x1fd, 0x1fc, 0x3, 0x2, 0x2, 0x2, 0x1fd, 0x1fe,
- 0x3, 0x2, 0x2, 0x2, 0x1fe, 0x200, 0x3, 0x2, 0x2,
- 0x2, 0x1ff, 0x1fb, 0x3, 0x2, 0x2, 0x2, 0x1ff, 0x200,
- 0x3, 0x2, 0x2, 0x2, 0x200, 0x205, 0x3, 0x2, 0x2,
- 0x2, 0x201, 0x203, 0x5, 0x4c, 0x27, 0x2, 0x202, 0x204,
- 0x7, 0x71, 0x2, 0x2, 0x203, 0x202, 0x3, 0x2, 0x2,
- 0x2, 0x203, 0x204, 0x3, 0x2, 0x2, 0x2, 0x204, 0x206,
- 0x3, 0x2, 0x2, 0x2, 0x205, 0x201, 0x3, 0x2, 0x2,
- 0x2, 0x205, 0x206, 0x3, 0x2, 0x2, 0x2, 0x206, 0x20b,
- 0x3, 0x2, 0x2, 0x2, 0x207, 0x209, 0x5, 0x48, 0x25,
- 0x2, 0x208, 0x20a, 0x7, 0x71, 0x2, 0x2, 0x209, 0x208,
- 0x3, 0x2, 0x2, 0x2, 0x209, 0x20a, 0x3, 0x2, 0x2,
- 0x2, 0x20a, 0x20c, 0x3, 0x2, 0x2, 0x2, 0x20b, 0x207,
- 0x3, 0x2, 0x2, 0x2, 0x20b, 0x20c, 0x3, 0x2, 0x2,
- 0x2, 0x20c, 0x20d, 0x3, 0x2, 0x2, 0x2, 0x20d, 0x20e,
- 0x7, 0x9, 0x2, 0x2, 0x20e, 0x41, 0x3, 0x2, 0x2,
- 0x2, 0x20f, 0x211, 0x5, 0x44, 0x23, 0x2, 0x210, 0x212,
- 0x7, 0x71, 0x2, 0x2, 0x211, 0x210, 0x3, 0x2, 0x2,
- 0x2, 0x211, 0x212, 0x3, 0x2, 0x2, 0x2, 0x212, 0x213,
- 0x3, 0x2, 0x2, 0x2, 0x213, 0x214, 0x5, 0x40, 0x21,
- 0x2, 0x214, 0x43, 0x3, 0x2, 0x2, 0x2, 0x215, 0x217,
- 0x5, 0x9a, 0x4e, 0x2, 0x216, 0x218, 0x7, 0x71, 0x2,
- 0x2, 0x217, 0x216, 0x3, 0x2, 0x2, 0x2, 0x217, 0x218,
- 0x3, 0x2, 0x2, 0x2, 0x218, 0x219, 0x3, 0x2, 0x2,
- 0x2, 0x219, 0x21b, 0x5, 0x9e, 0x50, 0x2, 0x21a, 0x21c,
- 0x7, 0x71, 0x2, 0x2, 0x21b, 0x21a, 0x3, 0x2, 0x2,
- 0x2, 0x21b, 0x21c, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x21e,
- 0x3, 0x2, 0x2, 0x2, 0x21d, 0x21f, 0x5, 0x46, 0x24,
- 0x2, 0x21e, 0x21d, 0x3, 0x2, 0x2, 0x2, 0x21e, 0x21f,
- 0x3, 0x2, 0x2, 0x2, 0x21f, 0x221, 0x3, 0x2, 0x2,
- 0x2, 0x220, 0x222, 0x7, 0x71, 0x2, 0x2, 0x221, 0x220,
- 0x3, 0x2, 0x2, 0x2, 0x221, 0x222, 0x3, 0x2, 0x2,
- 0x2, 0x222, 0x223, 0x3, 0x2, 0x2, 0x2, 0x223, 0x225,
- 0x5, 0x9e, 0x50, 0x2, 0x224, 0x226, 0x7, 0x71, 0x2,
- 0x2, 0x225, 0x224, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226,
- 0x3, 0x2, 0x2, 0x2, 0x226, 0x227, 0x3, 0x2, 0x2,
- 0x2, 0x227, 0x228, 0x5, 0x9c, 0x4f, 0x2, 0x228, 0x256,
- 0x3, 0x2, 0x2, 0x2, 0x229, 0x22b, 0x5, 0x9a, 0x4e,
- 0x2, 0x22a, 0x22c, 0x7, 0x71, 0x2, 0x2, 0x22b, 0x22a,
- 0x3, 0x2, 0x2, 0x2, 0x22b, 0x22c, 0x3, 0x2, 0x2,
- 0x2, 0x22c, 0x22d, 0x3, 0x2, 0x2, 0x2, 0x22d, 0x22f,
- 0x5, 0x9e, 0x50, 0x2, 0x22e, 0x230, 0x7, 0x71, 0x2,
- 0x2, 0x22f, 0x22e, 0x3, 0x2, 0x2, 0x2, 0x22f, 0x230,
- 0x3, 0x2, 0x2, 0x2, 0x230, 0x232, 0x3, 0x2, 0x2,
- 0x2, 0x231, 0x233, 0x5, 0x46, 0x24, 0x2, 0x232, 0x231,
- 0x3, 0x2, 0x2, 0x2, 0x232, 0x233, 0x3, 0x2, 0x2,
- 0x2, 0x233, 0x235, 0x3, 0x2, 0x2, 0x2, 0x234, 0x236,
- 0x7, 0x71, 0x2, 0x2, 0x235, 0x234, 0x3, 0x2, 0x2,
- 0x2, 0x235, 0x236, 0x3, 0x2, 0x2, 0x2, 0x236, 0x237,
- 0x3, 0x2, 0x2, 0x2, 0x237, 0x238, 0x5, 0x9e, 0x50,
- 0x2, 0x238, 0x256, 0x3, 0x2, 0x2, 0x2, 0x239, 0x23b,
- 0x5, 0x9e, 0x50, 0x2, 0x23a, 0x23c, 0x7, 0x71, 0x2,
- 0x2, 0x23b, 0x23a, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x23c,
- 0x3, 0x2, 0x2, 0x2, 0x23c, 0x23e, 0x3, 0x2, 0x2,
- 0x2, 0x23d, 0x23f, 0x5, 0x46, 0x24, 0x2, 0x23e, 0x23d,
- 0x3, 0x2, 0x2, 0x2, 0x23e, 0x23f, 0x3, 0x2, 0x2,
- 0x2, 0x23f, 0x241, 0x3, 0x2, 0x2, 0x2, 0x240, 0x242,
- 0x7, 0x71, 0x2, 0x2, 0x241, 0x240, 0x3, 0x2, 0x2,
- 0x2, 0x241, 0x242, 0x3, 0x2, 0x2, 0x2, 0x242, 0x243,
- 0x3, 0x2, 0x2, 0x2, 0x243, 0x245, 0x5, 0x9e, 0x50,
- 0x2, 0x244, 0x246, 0x7, 0x71, 0x2, 0x2, 0x245, 0x244,
- 0x3, 0x2, 0x2, 0x2, 0x245, 0x246, 0x3, 0x2, 0x2,
- 0x2, 0x246, 0x247, 0x3, 0x2, 0x2, 0x2, 0x247, 0x248,
- 0x5, 0x9c, 0x4f, 0x2, 0x248, 0x256, 0x3, 0x2, 0x2,
- 0x2, 0x249, 0x24b, 0x5, 0x9e, 0x50, 0x2, 0x24a, 0x24c,
- 0x7, 0x71, 0x2, 0x2, 0x24b, 0x24a, 0x3, 0x2, 0x2,
- 0x2, 0x24b, 0x24c, 0x3, 0x2, 0x2, 0x2, 0x24c, 0x24e,
- 0x3, 0x2, 0x2, 0x2, 0x24d, 0x24f, 0x5, 0x46, 0x24,
- 0x2, 0x24e, 0x24d, 0x3, 0x2, 0x2, 0x2, 0x24e, 0x24f,
- 0x3, 0x2, 0x2, 0x2, 0x24f, 0x251, 0x3, 0x2, 0x2,
- 0x2, 0x250, 0x252, 0x7, 0x71, 0x2, 0x2, 0x251, 0x250,
- 0x3, 0x2, 0x2, 0x2, 0x251, 0x252, 0x3, 0x2, 0x2,
- 0x2, 0x252, 0x253, 0x3, 0x2, 0x2, 0x2, 0x253, 0x254,
- 0x5, 0x9e, 0x50, 0x2, 0x254, 0x256, 0x3, 0x2, 0x2,
- 0x2, 0x255, 0x215, 0x3, 0x2, 0x2, 0x2, 0x255, 0x229,
- 0x3, 0x2, 0x2, 0x2, 0x255, 0x239, 0x3, 0x2, 0x2,
- 0x2, 0x255, 0x249, 0x3, 0x2, 0x2, 0x2, 0x256, 0x45,
- 0x3, 0x2, 0x2, 0x2, 0x257, 0x259, 0x7, 0xa, 0x2,
- 0x2, 0x258, 0x25a, 0x5, 0x88, 0x45, 0x2, 0x259, 0x258,
- 0x3, 0x2, 0x2, 0x2, 0x259, 0x25a, 0x3, 0x2, 0x2,
- 0x2, 0x25a, 0x25c, 0x3, 0x2, 0x2, 0x2, 0x25b, 0x25d,
- 0x7, 0xb, 0x2, 0x2, 0x25c, 0x25b, 0x3, 0x2, 0x2,
- 0x2, 0x25c, 0x25d, 0x3, 0x2, 0x2, 0x2, 0x25d, 0x25f,
- 0x3, 0x2, 0x2, 0x2, 0x25e, 0x260, 0x5, 0x4a, 0x26,
- 0x2, 0x25f, 0x25e, 0x3, 0x2, 0x2, 0x2, 0x25f, 0x260,
- 0x3, 0x2, 0x2, 0x2, 0x260, 0x262, 0x3, 0x2, 0x2,
- 0x2, 0x261, 0x263, 0x5, 0x50, 0x29, 0x2, 0x262, 0x261,
- 0x3, 0x2, 0x2, 0x2, 0x262, 0x263, 0x3, 0x2, 0x2,
- 0x2, 0x263, 0x265, 0x3, 0x2, 0x2, 0x2, 0x264, 0x266,
- 0x5, 0x48, 0x25, 0x2, 0x265, 0x264, 0x3, 0x2, 0x2,
- 0x2, 0x265, 0x266, 0x3, 0x2, 0x2, 0x2, 0x266, 0x267,
- 0x3, 0x2, 0x2, 0x2, 0x267, 0x268, 0x7, 0xc, 0x2,
- 0x2, 0x268, 0x47, 0x3, 0x2, 0x2, 0x2, 0x269, 0x26c,
- 0x5, 0x8c, 0x47, 0x2, 0x26a, 0x26c, 0x5, 0x8e, 0x48,
- 0x2, 0x26b, 0x269, 0x3, 0x2, 0x2, 0x2, 0x26b, 0x26a,
- 0x3, 0x2, 0x2, 0x2, 0x26c, 0x49, 0x3, 0x2, 0x2,
- 0x2, 0x26d, 0x26e, 0x7, 0xd, 0x2, 0x2, 0x26e, 0x27c,
- 0x5, 0x54, 0x2b, 0x2, 0x26f, 0x271, 0x7, 0x71, 0x2,
- 0x2, 0x270, 0x26f, 0x3, 0x2, 0x2, 0x2, 0x270, 0x271,
- 0x3, 0x2, 0x2, 0x2, 0x271, 0x272, 0x3, 0x2, 0x2,
- 0x2, 0x272, 0x274, 0x7, 0xe, 0x2, 0x2, 0x273, 0x275,
- 0x7, 0xd, 0x2, 0x2, 0x274, 0x273, 0x3, 0x2, 0x2,
- 0x2, 0x274, 0x275, 0x3, 0x2, 0x2, 0x2, 0x275, 0x277,
- 0x3, 0x2, 0x2, 0x2, 0x276, 0x278, 0x7, 0x71, 0x2,
- 0x2, 0x277, 0x276, 0x3, 0x2, 0x2, 0x2, 0x277, 0x278,
- 0x3, 0x2, 0x2, 0x2, 0x278, 0x279, 0x3, 0x2, 0x2,
- 0x2, 0x279, 0x27b, 0x5, 0x54, 0x2b, 0x2, 0x27a, 0x270,
- 0x3, 0x2, 0x2, 0x2, 0x27b, 0x27e, 0x3, 0x2, 0x2,
- 0x2, 0x27c, 0x27a, 0x3, 0x2, 0x2, 0x2, 0x27c, 0x27d,
- 0x3, 0x2, 0x2, 0x2, 0x27d, 0x4b, 0x3, 0x2, 0x2,
- 0x2, 0x27e, 0x27c, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x286,
- 0x5, 0x4e, 0x28, 0x2, 0x280, 0x282, 0x7, 0x71, 0x2,
- 0x2, 0x281, 0x280, 0x3, 0x2, 0x2, 0x2, 0x281, 0x282,
- 0x3, 0x2, 0x2, 0x2, 0x282, 0x283, 0x3, 0x2, 0x2,
- 0x2, 0x283, 0x285, 0x5, 0x4e, 0x28, 0x2, 0x284, 0x281,
- 0x3, 0x2, 0x2, 0x2, 0x285, 0x288, 0x3, 0x2, 0x2,
- 0x2, 0x286, 0x284, 0x3, 0x2, 0x2, 0x2, 0x286, 0x287,
- 0x3, 0x2, 0x2, 0x2, 0x287, 0x4d, 0x3, 0x2, 0x2,
- 0x2, 0x288, 0x286, 0x3, 0x2, 0x2, 0x2, 0x289, 0x28a,
- 0x7, 0xd, 0x2, 0x2, 0x28a, 0x28b, 0x5, 0x52, 0x2a,
- 0x2, 0x28b, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x28c, 0x28e,
- 0x7, 0x7, 0x2, 0x2, 0x28d, 0x28f, 0x7, 0x71, 0x2,
- 0x2, 0x28e, 0x28d, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x28f,
- 0x3, 0x2, 0x2, 0x2, 0x28f, 0x294, 0x3, 0x2, 0x2,
- 0x2, 0x290, 0x292, 0x5, 0x94, 0x4b, 0x2, 0x291, 0x293,
- 0x7, 0x71, 0x2, 0x2, 0x292, 0x291, 0x3, 0x2, 0x2,
- 0x2, 0x292, 0x293, 0x3, 0x2, 0x2, 0x2, 0x293, 0x295,
- 0x3, 0x2, 0x2, 0x2, 0x294, 0x290, 0x3, 0x2, 0x2,
- 0x2, 0x294, 0x295, 0x3, 0x2, 0x2, 0x2, 0x295, 0x2a0,
- 0x3, 0x2, 0x2, 0x2, 0x296, 0x298, 0x7, 0xf, 0x2,
- 0x2, 0x297, 0x299, 0x7, 0x71, 0x2, 0x2, 0x298, 0x297,
- 0x3, 0x2, 0x2, 0x2, 0x298, 0x299, 0x3, 0x2, 0x2,
- 0x2, 0x299, 0x29e, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x29c,
- 0x5, 0x94, 0x4b, 0x2, 0x29b, 0x29d, 0x7, 0x71, 0x2,
- 0x2, 0x29c, 0x29b, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x29d,
- 0x3, 0x2, 0x2, 0x2, 0x29d, 0x29f, 0x3, 0x2, 0x2,
- 0x2, 0x29e, 0x29a, 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29f,
- 0x3, 0x2, 0x2, 0x2, 0x29f, 0x2a1, 0x3, 0x2, 0x2,
- 0x2, 0x2a0, 0x296, 0x3, 0x2, 0x2, 0x2, 0x2a0, 0x2a1,
- 0x3, 0x2, 0x2, 0x2, 0x2a1, 0x51, 0x3, 0x2, 0x2,
- 0x2, 0x2a2, 0x2a3, 0x5, 0x98, 0x4d, 0x2, 0x2a3, 0x53,
- 0x3, 0x2, 0x2, 0x2, 0x2a4, 0x2a5, 0x5, 0x98, 0x4d,
- 0x2, 0x2a5, 0x55, 0x3, 0x2, 0x2, 0x2, 0x2a6, 0x2a7,
- 0x5, 0x58, 0x2d, 0x2, 0x2a7, 0x57, 0x3, 0x2, 0x2,
- 0x2, 0x2a8, 0x2af, 0x5, 0x5a, 0x2e, 0x2, 0x2a9, 0x2aa,
- 0x7, 0x71, 0x2, 0x2, 0x2aa, 0x2ab, 0x7, 0x5b, 0x2,
- 0x2, 0x2ab, 0x2ac, 0x7, 0x71, 0x2, 0x2, 0x2ac, 0x2ae,
- 0x5, 0x5a, 0x2e, 0x2, 0x2ad, 0x2a9, 0x3, 0x2, 0x2,
- 0x2, 0x2ae, 0x2b1, 0x3, 0x2, 0x2, 0x2, 0x2af, 0x2ad,
- 0x3, 0x2, 0x2, 0x2, 0x2af, 0x2b0, 0x3, 0x2, 0x2,
- 0x2, 0x2b0, 0x59, 0x3, 0x2, 0x2, 0x2, 0x2b1, 0x2af,
- 0x3, 0x2, 0x2, 0x2, 0x2b2, 0x2b9, 0x5, 0x5c, 0x2f,
- 0x2, 0x2b3, 0x2b4, 0x7, 0x71, 0x2, 0x2, 0x2b4, 0x2b5,
- 0x7, 0x5c, 0x2, 0x2, 0x2b5, 0x2b6, 0x7, 0x71, 0x2,
- 0x2, 0x2b6, 0x2b8, 0x5, 0x5c, 0x2f, 0x2, 0x2b7, 0x2b3,
- 0x3, 0x2, 0x2, 0x2, 0x2b8, 0x2bb, 0x3, 0x2, 0x2,
- 0x2, 0x2b9, 0x2b7, 0x3, 0x2, 0x2, 0x2, 0x2b9, 0x2ba,
- 0x3, 0x2, 0x2, 0x2, 0x2ba, 0x5b, 0x3, 0x2, 0x2,
- 0x2, 0x2bb, 0x2b9, 0x3, 0x2, 0x2, 0x2, 0x2bc, 0x2c3,
- 0x5, 0x5e, 0x30, 0x2, 0x2bd, 0x2be, 0x7, 0x71, 0x2,
- 0x2, 0x2be, 0x2bf, 0x7, 0x5d, 0x2, 0x2, 0x2bf, 0x2c0,
- 0x7, 0x71, 0x2, 0x2, 0x2c0, 0x2c2, 0x5, 0x5e, 0x30,
- 0x2, 0x2c1, 0x2bd, 0x3, 0x2, 0x2, 0x2, 0x2c2, 0x2c5,
- 0x3, 0x2, 0x2, 0x2, 0x2c3, 0x2c1, 0x3, 0x2, 0x2,
- 0x2, 0x2c3, 0x2c4, 0x3, 0x2, 0x2, 0x2, 0x2c4, 0x5d,
- 0x3, 0x2, 0x2, 0x2, 0x2c5, 0x2c3, 0x3, 0x2, 0x2,
- 0x2, 0x2c6, 0x2c8, 0x7, 0x5e, 0x2, 0x2, 0x2c7, 0x2c9,
- 0x7, 0x71, 0x2, 0x2, 0x2c8, 0x2c7, 0x3, 0x2, 0x2,
- 0x2, 0x2c8, 0x2c9, 0x3, 0x2, 0x2, 0x2, 0x2c9, 0x2cb,
- 0x3, 0x2, 0x2, 0x2, 0x2ca, 0x2c6, 0x3, 0x2, 0x2,
- 0x2, 0x2cb, 0x2ce, 0x3, 0x2, 0x2, 0x2, 0x2cc, 0x2ca,
- 0x3, 0x2, 0x2, 0x2, 0x2cc, 0x2cd, 0x3, 0x2, 0x2,
- 0x2, 0x2cd, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2cc,
- 0x3, 0x2, 0x2, 0x2, 0x2cf, 0x2d0, 0x5, 0x60, 0x31,
- 0x2, 0x2d0, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x2d1, 0x2d8,
- 0x5, 0x62, 0x32, 0x2, 0x2d2, 0x2d4, 0x7, 0x71, 0x2,
- 0x2, 0x2d3, 0x2d2, 0x3, 0x2, 0x2, 0x2, 0x2d3, 0x2d4,
- 0x3, 0x2, 0x2, 0x2, 0x2d4, 0x2d5, 0x3, 0x2, 0x2,
- 0x2, 0x2d5, 0x2d7, 0x5, 0x76, 0x3c, 0x2, 0x2d6, 0x2d3,
- 0x3, 0x2, 0x2, 0x2, 0x2d7, 0x2da, 0x3, 0x2, 0x2,
- 0x2, 0x2d8, 0x2d6, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2d9,
- 0x3, 0x2, 0x2, 0x2, 0x2d9, 0x61, 0x3, 0x2, 0x2,
- 0x2, 0x2da, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0x2db, 0x2ee,
- 0x5, 0x64, 0x33, 0x2, 0x2dc, 0x2de, 0x7, 0x71, 0x2,
- 0x2, 0x2dd, 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x2dd, 0x2de,
- 0x3, 0x2, 0x2, 0x2, 0x2de, 0x2df, 0x3, 0x2, 0x2,
- 0x2, 0x2df, 0x2e1, 0x7, 0x10, 0x2, 0x2, 0x2e0, 0x2e2,
- 0x7, 0x71, 0x2, 0x2, 0x2e1, 0x2e0, 0x3, 0x2, 0x2,
- 0x2, 0x2e1, 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2e2, 0x2e3,
- 0x3, 0x2, 0x2, 0x2, 0x2e3, 0x2ed, 0x5, 0x64, 0x33,
- 0x2, 0x2e4, 0x2e6, 0x7, 0x71, 0x2, 0x2, 0x2e5, 0x2e4,
- 0x3, 0x2, 0x2, 0x2, 0x2e5, 0x2e6, 0x3, 0x2, 0x2,
- 0x2, 0x2e6, 0x2e7, 0x3, 0x2, 0x2, 0x2, 0x2e7, 0x2e9,
- 0x7, 0x11, 0x2, 0x2, 0x2e8, 0x2ea, 0x7, 0x71, 0x2,
- 0x2, 0x2e9, 0x2e8, 0x3, 0x2, 0x2, 0x2, 0x2e9, 0x2ea,
- 0x3, 0x2, 0x2, 0x2, 0x2ea, 0x2eb, 0x3, 0x2, 0x2,
- 0x2, 0x2eb, 0x2ed, 0x5, 0x64, 0x33, 0x2, 0x2ec, 0x2dd,
- 0x3, 0x2, 0x2, 0x2, 0x2ec, 0x2e5, 0x3, 0x2, 0x2,
- 0x2, 0x2ed, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2ee, 0x2ec,
- 0x3, 0x2, 0x2, 0x2, 0x2ee, 0x2ef, 0x3, 0x2, 0x2,
- 0x2, 0x2ef, 0x63, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2ee,
- 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x30c, 0x5, 0x66, 0x34,
- 0x2, 0x2f2, 0x2f4, 0x7, 0x71, 0x2, 0x2, 0x2f3, 0x2f2,
- 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2f4, 0x3, 0x2, 0x2,
- 0x2, 0x2f4, 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x2f5, 0x2f7,
- 0x7, 0x7, 0x2, 0x2, 0x2f6, 0x2f8, 0x7, 0x71, 0x2,
- 0x2, 0x2f7, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x2f7, 0x2f8,
- 0x3, 0x2, 0x2, 0x2, 0x2f8, 0x2f9, 0x3, 0x2, 0x2,
- 0x2, 0x2f9, 0x30b, 0x5, 0x66, 0x34, 0x2, 0x2fa, 0x2fc,
- 0x7, 0x71, 0x2, 0x2, 0x2fb, 0x2fa, 0x3, 0x2, 0x2,
- 0x2, 0x2fb, 0x2fc, 0x3, 0x2, 0x2, 0x2, 0x2fc, 0x2fd,
- 0x3, 0x2, 0x2, 0x2, 0x2fd, 0x2ff, 0x7, 0x12, 0x2,
- 0x2, 0x2fe, 0x300, 0x7, 0x71, 0x2, 0x2, 0x2ff, 0x2fe,
- 0x3, 0x2, 0x2, 0x2, 0x2ff, 0x300, 0x3, 0x2, 0x2,
- 0x2, 0x300, 0x301, 0x3, 0x2, 0x2, 0x2, 0x301, 0x30b,
- 0x5, 0x66, 0x34, 0x2, 0x302, 0x304, 0x7, 0x71, 0x2,
- 0x2, 0x303, 0x302, 0x3, 0x2, 0x2, 0x2, 0x303, 0x304,
- 0x3, 0x2, 0x2, 0x2, 0x304, 0x305, 0x3, 0x2, 0x2,
- 0x2, 0x305, 0x307, 0x7, 0x13, 0x2, 0x2, 0x306, 0x308,
- 0x7, 0x71, 0x2, 0x2, 0x307, 0x306, 0x3, 0x2, 0x2,
- 0x2, 0x307, 0x308, 0x3, 0x2, 0x2, 0x2, 0x308, 0x309,
- 0x3, 0x2, 0x2, 0x2, 0x309, 0x30b, 0x5, 0x66, 0x34,
- 0x2, 0x30a, 0x2f3, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x2fb,
- 0x3, 0x2, 0x2, 0x2, 0x30a, 0x303, 0x3, 0x2, 0x2,
- 0x2, 0x30b, 0x30e, 0x3, 0x2, 0x2, 0x2, 0x30c, 0x30a,
- 0x3, 0x2, 0x2, 0x2, 0x30c, 0x30d, 0x3, 0x2, 0x2,
- 0x2, 0x30d, 0x65, 0x3, 0x2, 0x2, 0x2, 0x30e, 0x30c,
- 0x3, 0x2, 0x2, 0x2, 0x30f, 0x31a, 0x5, 0x68, 0x35,
- 0x2, 0x310, 0x312, 0x7, 0x71, 0x2, 0x2, 0x311, 0x310,
- 0x3, 0x2, 0x2, 0x2, 0x311, 0x312, 0x3, 0x2, 0x2,
- 0x2, 0x312, 0x313, 0x3, 0x2, 0x2, 0x2, 0x313, 0x315,
- 0x7, 0x14, 0x2, 0x2, 0x314, 0x316, 0x7, 0x71, 0x2,
- 0x2, 0x315, 0x314, 0x3, 0x2, 0x2, 0x2, 0x315, 0x316,
- 0x3, 0x2, 0x2, 0x2, 0x316, 0x317, 0x3, 0x2, 0x2,
- 0x2, 0x317, 0x319, 0x5, 0x68, 0x35, 0x2, 0x318, 0x311,
- 0x3, 0x2, 0x2, 0x2, 0x319, 0x31c, 0x3, 0x2, 0x2,
- 0x2, 0x31a, 0x318, 0x3, 0x2, 0x2, 0x2, 0x31a, 0x31b,
- 0x3, 0x2, 0x2, 0x2, 0x31b, 0x67, 0x3, 0x2, 0x2,
- 0x2, 0x31c, 0x31a, 0x3, 0x2, 0x2, 0x2, 0x31d, 0x31f,
- 0x9, 0x3, 0x2, 0x2, 0x31e, 0x320, 0x7, 0x71, 0x2,
- 0x2, 0x31f, 0x31e, 0x3, 0x2, 0x2, 0x2, 0x31f, 0x320,
- 0x3, 0x2, 0x2, 0x2, 0x320, 0x322, 0x3, 0x2, 0x2,
- 0x2, 0x321, 0x31d, 0x3, 0x2, 0x2, 0x2, 0x322, 0x325,
- 0x3, 0x2, 0x2, 0x2, 0x323, 0x321, 0x3, 0x2, 0x2,
- 0x2, 0x323, 0x324, 0x3, 0x2, 0x2, 0x2, 0x324, 0x326,
- 0x3, 0x2, 0x2, 0x2, 0x325, 0x323, 0x3, 0x2, 0x2,
- 0x2, 0x326, 0x327, 0x5, 0x6a, 0x36, 0x2, 0x327, 0x69,
- 0x3, 0x2, 0x2, 0x2, 0x328, 0x35e, 0x5, 0x6c, 0x37,
- 0x2, 0x329, 0x32b, 0x7, 0x71, 0x2, 0x2, 0x32a, 0x329,
- 0x3, 0x2, 0x2, 0x2, 0x32a, 0x32b, 0x3, 0x2, 0x2,
- 0x2, 0x32b, 0x32c, 0x3, 0x2, 0x2, 0x2, 0x32c, 0x32d,
- 0x7, 0xa, 0x2, 0x2, 0x32d, 0x32e, 0x5, 0x56, 0x2c,
- 0x2, 0x32e, 0x32f, 0x7, 0xc, 0x2, 0x2, 0x32f, 0x35d,
- 0x3, 0x2, 0x2, 0x2, 0x330, 0x332, 0x7, 0x71, 0x2,
- 0x2, 0x331, 0x330, 0x3, 0x2, 0x2, 0x2, 0x331, 0x332,
- 0x3, 0x2, 0x2, 0x2, 0x332, 0x333, 0x3, 0x2, 0x2,
- 0x2, 0x333, 0x335, 0x7, 0xa, 0x2, 0x2, 0x334, 0x336,
- 0x5, 0x56, 0x2c, 0x2, 0x335, 0x334, 0x3, 0x2, 0x2,
- 0x2, 0x335, 0x336, 0x3, 0x2, 0x2, 0x2, 0x336, 0x337,
- 0x3, 0x2, 0x2, 0x2, 0x337, 0x339, 0x7, 0xf, 0x2,
- 0x2, 0x338, 0x33a, 0x5, 0x56, 0x2c, 0x2, 0x339, 0x338,
- 0x3, 0x2, 0x2, 0x2, 0x339, 0x33a, 0x3, 0x2, 0x2,
- 0x2, 0x33a, 0x33b, 0x3, 0x2, 0x2, 0x2, 0x33b, 0x35d,
- 0x7, 0xc, 0x2, 0x2, 0x33c, 0x33e, 0x7, 0x71, 0x2,
- 0x2, 0x33d, 0x33c, 0x3, 0x2, 0x2, 0x2, 0x33d, 0x33e,
- 0x3, 0x2, 0x2, 0x2, 0x33e, 0x33f, 0x3, 0x2, 0x2,
- 0x2, 0x33f, 0x34d, 0x7, 0x15, 0x2, 0x2, 0x340, 0x341,
- 0x7, 0x71, 0x2, 0x2, 0x341, 0x34d, 0x7, 0x5f, 0x2,
- 0x2, 0x342, 0x343, 0x7, 0x71, 0x2, 0x2, 0x343, 0x344,
- 0x7, 0x60, 0x2, 0x2, 0x344, 0x345, 0x7, 0x71, 0x2,
- 0x2, 0x345, 0x34d, 0x7, 0x4f, 0x2, 0x2, 0x346, 0x347,
- 0x7, 0x71, 0x2, 0x2, 0x347, 0x348, 0x7, 0x61, 0x2,
- 0x2, 0x348, 0x349, 0x7, 0x71, 0x2, 0x2, 0x349, 0x34d,
- 0x7, 0x4f, 0x2, 0x2, 0x34a, 0x34b, 0x7, 0x71, 0x2,
- 0x2, 0x34b, 0x34d, 0x7, 0x62, 0x2, 0x2, 0x34c, 0x33d,
- 0x3, 0x2, 0x2, 0x2, 0x34c, 0x340, 0x3, 0x2, 0x2,
- 0x2, 0x34c, 0x342, 0x3, 0x2, 0x2, 0x2, 0x34c, 0x346,
- 0x3, 0x2, 0x2, 0x2, 0x34c, 0x34a, 0x3, 0x2, 0x2,
- 0x2, 0x34d, 0x34f, 0x3, 0x2, 0x2, 0x2, 0x34e, 0x350,
- 0x7, 0x71, 0x2, 0x2, 0x34f, 0x34e, 0x3, 0x2, 0x2,
- 0x2, 0x34f, 0x350, 0x3, 0x2, 0x2, 0x2, 0x350, 0x351,
- 0x3, 0x2, 0x2, 0x2, 0x351, 0x35d, 0x5, 0x6c, 0x37,
- 0x2, 0x352, 0x353, 0x7, 0x71, 0x2, 0x2, 0x353, 0x354,
- 0x7, 0x63, 0x2, 0x2, 0x354, 0x355, 0x7, 0x71, 0x2,
- 0x2, 0x355, 0x35d, 0x7, 0x64, 0x2, 0x2, 0x356, 0x357,
- 0x7, 0x71, 0x2, 0x2, 0x357, 0x358, 0x7, 0x63, 0x2,
- 0x2, 0x358, 0x359, 0x7, 0x71, 0x2, 0x2, 0x359, 0x35a,
- 0x7, 0x5e, 0x2, 0x2, 0x35a, 0x35b, 0x7, 0x71, 0x2,
- 0x2, 0x35b, 0x35d, 0x7, 0x64, 0x2, 0x2, 0x35c, 0x32a,
- 0x3, 0x2, 0x2, 0x2, 0x35c, 0x331, 0x3, 0x2, 0x2,
- 0x2, 0x35c, 0x34c, 0x3, 0x2, 0x2, 0x2, 0x35c, 0x352,
- 0x3, 0x2, 0x2, 0x2, 0x35c, 0x356, 0x3, 0x2, 0x2,
- 0x2, 0x35d, 0x360, 0x3, 0x2, 0x2, 0x2, 0x35e, 0x35c,
- 0x3, 0x2, 0x2, 0x2, 0x35e, 0x35f, 0x3, 0x2, 0x2,
- 0x2, 0x35f, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x360, 0x35e,
- 0x3, 0x2, 0x2, 0x2, 0x361, 0x366, 0x5, 0x6e, 0x38,
- 0x2, 0x362, 0x365, 0x5, 0x86, 0x44, 0x2, 0x363, 0x365,
- 0x5, 0x4c, 0x27, 0x2, 0x364, 0x362, 0x3, 0x2, 0x2,
- 0x2, 0x364, 0x363, 0x3, 0x2, 0x2, 0x2, 0x365, 0x368,
- 0x3, 0x2, 0x2, 0x2, 0x366, 0x364, 0x3, 0x2, 0x2,
- 0x2, 0x366, 0x367, 0x3, 0x2, 0x2, 0x2, 0x367, 0x6d,
- 0x3, 0x2, 0x2, 0x2, 0x368, 0x366, 0x3, 0x2, 0x2,
- 0x2, 0x369, 0x3d9, 0x5, 0x70, 0x39, 0x2, 0x36a, 0x3d9,
- 0x5, 0x8e, 0x48, 0x2, 0x36b, 0x36d, 0x7, 0x65, 0x2,
- 0x2, 0x36c, 0x36e, 0x7, 0x71, 0x2, 0x2, 0x36d, 0x36c,
- 0x3, 0x2, 0x2, 0x2, 0x36d, 0x36e, 0x3, 0x2, 0x2,
- 0x2, 0x36e, 0x36f, 0x3, 0x2, 0x2, 0x2, 0x36f, 0x371,
- 0x7, 0x8, 0x2, 0x2, 0x370, 0x372, 0x7, 0x71, 0x2,
- 0x2, 0x371, 0x370, 0x3, 0x2, 0x2, 0x2, 0x371, 0x372,
- 0x3, 0x2, 0x2, 0x2, 0x372, 0x373, 0x3, 0x2, 0x2,
- 0x2, 0x373, 0x375, 0x7, 0x7, 0x2, 0x2, 0x374, 0x376,
- 0x7, 0x71, 0x2, 0x2, 0x375, 0x374, 0x3, 0x2, 0x2,
- 0x2, 0x375, 0x376, 0x3, 0x2, 0x2, 0x2, 0x376, 0x377,
- 0x3, 0x2, 0x2, 0x2, 0x377, 0x3d9, 0x7, 0x9, 0x2,
- 0x2, 0x378, 0x3d9, 0x5, 0x84, 0x43, 0x2, 0x379, 0x37b,
- 0x7, 0x66, 0x2, 0x2, 0x37a, 0x37c, 0x7, 0x71, 0x2,
- 0x2, 0x37b, 0x37a, 0x3, 0x2, 0x2, 0x2, 0x37b, 0x37c,
- 0x3, 0x2, 0x2, 0x2, 0x37c, 0x37d, 0x3, 0x2, 0x2,
- 0x2, 0x37d, 0x37f, 0x7, 0x8, 0x2, 0x2, 0x37e, 0x380,
- 0x7, 0x71, 0x2, 0x2, 0x37f, 0x37e, 0x3, 0x2, 0x2,
- 0x2, 0x37f, 0x380, 0x3, 0x2, 0x2, 0x2, 0x380, 0x381,
- 0x3, 0x2, 0x2, 0x2, 0x381, 0x383, 0x5, 0x7c, 0x3f,
- 0x2, 0x382, 0x384, 0x7, 0x71, 0x2, 0x2, 0x383, 0x382,
- 0x3, 0x2, 0x2, 0x2, 0x383, 0x384, 0x3, 0x2, 0x2,
- 0x2, 0x384, 0x385, 0x3, 0x2, 0x2, 0x2, 0x385, 0x386,
- 0x7, 0x9, 0x2, 0x2, 0x386, 0x3d9, 0x3, 0x2, 0x2,
- 0x2, 0x387, 0x389, 0x7, 0x67, 0x2, 0x2, 0x388, 0x38a,
- 0x7, 0x71, 0x2, 0x2, 0x389, 0x388, 0x3, 0x2, 0x2,
- 0x2, 0x389, 0x38a, 0x3, 0x2, 0x2, 0x2, 0x38a, 0x38b,
- 0x3, 0x2, 0x2, 0x2, 0x38b, 0x38d, 0x7, 0x8, 0x2,
- 0x2, 0x38c, 0x38e, 0x7, 0x71, 0x2, 0x2, 0x38d, 0x38c,
- 0x3, 0x2, 0x2, 0x2, 0x38d, 0x38e, 0x3, 0x2, 0x2,
- 0x2, 0x38e, 0x38f, 0x3, 0x2, 0x2, 0x2, 0x38f, 0x391,
- 0x5, 0x7c, 0x3f, 0x2, 0x390, 0x392, 0x7, 0x71, 0x2,
- 0x2, 0x391, 0x390, 0x3, 0x2, 0x2, 0x2, 0x391, 0x392,
- 0x3, 0x2, 0x2, 0x2, 0x392, 0x398, 0x3, 0x2, 0x2,
- 0x2, 0x393, 0x395, 0x7, 0x71, 0x2, 0x2, 0x394, 0x393,
- 0x3, 0x2, 0x2, 0x2, 0x394, 0x395, 0x3, 0x2, 0x2,
- 0x2, 0x395, 0x396, 0x3, 0x2, 0x2, 0x2, 0x396, 0x397,
- 0x7, 0xe, 0x2, 0x2, 0x397, 0x399, 0x5, 0x56, 0x2c,
- 0x2, 0x398, 0x394, 0x3, 0x2, 0x2, 0x2, 0x398, 0x399,
- 0x3, 0x2, 0x2, 0x2, 0x399, 0x39a, 0x3, 0x2, 0x2,
- 0x2, 0x39a, 0x39b, 0x7, 0x9, 0x2, 0x2, 0x39b, 0x3d9,
- 0x3, 0x2, 0x2, 0x2, 0x39c, 0x39e, 0x7, 0x43, 0x2,
- 0x2, 0x39d, 0x39f, 0x7, 0x71, 0x2, 0x2, 0x39e, 0x39d,
- 0x3, 0x2, 0x2, 0x2, 0x39e, 0x39f, 0x3, 0x2, 0x2,
- 0x2, 0x39f, 0x3a0, 0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a2,
- 0x7, 0x8, 0x2, 0x2, 0x3a1, 0x3a3, 0x7, 0x71, 0x2,
- 0x2, 0x3a2, 0x3a1, 0x3, 0x2, 0x2, 0x2, 0x3a2, 0x3a3,
- 0x3, 0x2, 0x2, 0x2, 0x3a3, 0x3a4, 0x3, 0x2, 0x2,
- 0x2, 0x3a4, 0x3a6, 0x5, 0x7c, 0x3f, 0x2, 0x3a5, 0x3a7,
- 0x7, 0x71, 0x2, 0x2, 0x3a6, 0x3a5, 0x3, 0x2, 0x2,
- 0x2, 0x3a6, 0x3a7, 0x3, 0x2, 0x2, 0x2, 0x3a7, 0x3a8,
- 0x3, 0x2, 0x2, 0x2, 0x3a8, 0x3a9, 0x7, 0x9, 0x2,
- 0x2, 0x3a9, 0x3d9, 0x3, 0x2, 0x2, 0x2, 0x3aa, 0x3ac,
- 0x7, 0x68, 0x2, 0x2, 0x3ab, 0x3ad, 0x7, 0x71, 0x2,
- 0x2, 0x3ac, 0x3ab, 0x3, 0x2, 0x2, 0x2, 0x3ac, 0x3ad,
- 0x3, 0x2, 0x2, 0x2, 0x3ad, 0x3ae, 0x3, 0x2, 0x2,
- 0x2, 0x3ae, 0x3b0, 0x7, 0x8, 0x2, 0x2, 0x3af, 0x3b1,
- 0x7, 0x71, 0x2, 0x2, 0x3b0, 0x3af, 0x3, 0x2, 0x2,
- 0x2, 0x3b0, 0x3b1, 0x3, 0x2, 0x2, 0x2, 0x3b1, 0x3b2,
- 0x3, 0x2, 0x2, 0x2, 0x3b2, 0x3b4, 0x5, 0x7c, 0x3f,
- 0x2, 0x3b3, 0x3b5, 0x7, 0x71, 0x2, 0x2, 0x3b4, 0x3b3,
- 0x3, 0x2, 0x2, 0x2, 0x3b4, 0x3b5, 0x3, 0x2, 0x2,
- 0x2, 0x3b5, 0x3b6, 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b7,
- 0x7, 0x9, 0x2, 0x2, 0x3b7, 0x3d9, 0x3, 0x2, 0x2,
- 0x2, 0x3b8, 0x3ba, 0x7, 0x69, 0x2, 0x2, 0x3b9, 0x3bb,
- 0x7, 0x71, 0x2, 0x2, 0x3ba, 0x3b9, 0x3, 0x2, 0x2,
- 0x2, 0x3ba, 0x3bb, 0x3, 0x2, 0x2, 0x2, 0x3bb, 0x3bc,
- 0x3, 0x2, 0x2, 0x2, 0x3bc, 0x3be, 0x7, 0x8, 0x2,
- 0x2, 0x3bd, 0x3bf, 0x7, 0x71, 0x2, 0x2, 0x3be, 0x3bd,
- 0x3, 0x2, 0x2, 0x2, 0x3be, 0x3bf, 0x3, 0x2, 0x2,
- 0x2, 0x3bf, 0x3c0, 0x3, 0x2, 0x2, 0x2, 0x3c0, 0x3c2,
- 0x5, 0x7c, 0x3f, 0x2, 0x3c1, 0x3c3, 0x7, 0x71, 0x2,
- 0x2, 0x3c2, 0x3c1, 0x3, 0x2, 0x2, 0x2, 0x3c2, 0x3c3,
- 0x3, 0x2, 0x2, 0x2, 0x3c3, 0x3c4, 0x3, 0x2, 0x2,
- 0x2, 0x3c4, 0x3c5, 0x7, 0x9, 0x2, 0x2, 0x3c5, 0x3d9,
- 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3c8, 0x7, 0x6a, 0x2,
- 0x2, 0x3c7, 0x3c9, 0x7, 0x71, 0x2, 0x2, 0x3c8, 0x3c7,
- 0x3, 0x2, 0x2, 0x2, 0x3c8, 0x3c9, 0x3, 0x2, 0x2,
- 0x2, 0x3c9, 0x3ca, 0x3, 0x2, 0x2, 0x2, 0x3ca, 0x3cc,
- 0x7, 0x8, 0x2, 0x2, 0x3cb, 0x3cd, 0x7, 0x71, 0x2,
- 0x2, 0x3cc, 0x3cb, 0x3, 0x2, 0x2, 0x2, 0x3cc, 0x3cd,
- 0x3, 0x2, 0x2, 0x2, 0x3cd, 0x3ce, 0x3, 0x2, 0x2,
- 0x2, 0x3ce, 0x3d0, 0x5, 0x7c, 0x3f, 0x2, 0x3cf, 0x3d1,
- 0x7, 0x71, 0x2, 0x2, 0x3d0, 0x3cf, 0x3, 0x2, 0x2,
- 0x2, 0x3d0, 0x3d1, 0x3, 0x2, 0x2, 0x2, 0x3d1, 0x3d2,
- 0x3, 0x2, 0x2, 0x2, 0x3d2, 0x3d3, 0x7, 0x9, 0x2,
- 0x2, 0x3d3, 0x3d9, 0x3, 0x2, 0x2, 0x2, 0x3d4, 0x3d9,
- 0x5, 0x7a, 0x3e, 0x2, 0x3d5, 0x3d9, 0x5, 0x78, 0x3d,
- 0x2, 0x3d6, 0x3d9, 0x5, 0x80, 0x41, 0x2, 0x3d7, 0x3d9,
- 0x5, 0x88, 0x45, 0x2, 0x3d8, 0x369, 0x3, 0x2, 0x2,
- 0x2, 0x3d8, 0x36a, 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x36b,
- 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x378, 0x3, 0x2, 0x2,
- 0x2, 0x3d8, 0x379, 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x387,
- 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x39c, 0x3, 0x2, 0x2,
- 0x2, 0x3d8, 0x3aa, 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x3b8,
- 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x3c6, 0x3, 0x2, 0x2,
- 0x2, 0x3d8, 0x3d4, 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x3d5,
- 0x3, 0x2, 0x2, 0x2, 0x3d8, 0x3d6, 0x3, 0x2, 0x2,
- 0x2, 0x3d8, 0x3d7, 0x3, 0x2, 0x2, 0x2, 0x3d9, 0x6f,
- 0x3, 0x2, 0x2, 0x2, 0x3da, 0x3e1, 0x5, 0x8a, 0x46,
- 0x2, 0x3db, 0x3e1, 0x7, 0x34, 0x2, 0x2, 0x3dc, 0x3e1,
- 0x5, 0x72, 0x3a, 0x2, 0x3dd, 0x3e1, 0x7, 0x64, 0x2,
- 0x2, 0x3de, 0x3e1, 0x5, 0x8c, 0x47, 0x2, 0x3df, 0x3e1,
- 0x5, 0x74, 0x3b, 0x2, 0x3e0, 0x3da, 0x3, 0x2, 0x2,
- 0x2, 0x3e0, 0x3db, 0x3, 0x2, 0x2, 0x2, 0x3e0, 0x3dc,
- 0x3, 0x2, 0x2, 0x2, 0x3e0, 0x3dd, 0x3, 0x2, 0x2,
- 0x2, 0x3e0, 0x3de, 0x3, 0x2, 0x2, 0x2, 0x3e0, 0x3df,
- 0x3, 0x2, 0x2, 0x2, 0x3e1, 0x71, 0x3, 0x2, 0x2,
- 0x2, 0x3e2, 0x3e3, 0x9, 0x4, 0x2, 0x2, 0x3e3, 0x73,
- 0x3, 0x2, 0x2, 0x2, 0x3e4, 0x3e6, 0x7, 0xa, 0x2,
- 0x2, 0x3e5, 0x3e7, 0x7, 0x71, 0x2, 0x2, 0x3e6, 0x3e5,
- 0x3, 0x2, 0x2, 0x2, 0x3e6, 0x3e7, 0x3, 0x2, 0x2,
- 0x2, 0x3e7, 0x3f9, 0x3, 0x2, 0x2, 0x2, 0x3e8, 0x3ea,
- 0x5, 0x56, 0x2c, 0x2, 0x3e9, 0x3eb, 0x7, 0x71, 0x2,
- 0x2, 0x3ea, 0x3e9, 0x3, 0x2, 0x2, 0x2, 0x3ea, 0x3eb,
- 0x3, 0x2, 0x2, 0x2, 0x3eb, 0x3f6, 0x3, 0x2, 0x2,
- 0x2, 0x3ec, 0x3ee, 0x7, 0x4, 0x2, 0x2, 0x3ed, 0x3ef,
- 0x7, 0x71, 0x2, 0x2, 0x3ee, 0x3ed, 0x3, 0x2, 0x2,
- 0x2, 0x3ee, 0x3ef, 0x3, 0x2, 0x2, 0x2, 0x3ef, 0x3f0,
- 0x3, 0x2, 0x2, 0x2, 0x3f0, 0x3f2, 0x5, 0x56, 0x2c,
- 0x2, 0x3f1, 0x3f3, 0x7, 0x71, 0x2, 0x2, 0x3f2, 0x3f1,
- 0x3, 0x2, 0x2, 0x2, 0x3f2, 0x3f3, 0x3, 0x2, 0x2,
- 0x2, 0x3f3, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0x3f4, 0x3ec,
- 0x3, 0x2, 0x2, 0x2, 0x3f5, 0x3f8, 0x3, 0x2, 0x2,
- 0x2, 0x3f6, 0x3f4, 0x3, 0x2, 0x2, 0x2, 0x3f6, 0x3f7,
- 0x3, 0x2, 0x2, 0x2, 0x3f7, 0x3fa, 0x3, 0x2, 0x2,
- 0x2, 0x3f8, 0x3f6, 0x3, 0x2, 0x2, 0x2, 0x3f9, 0x3e8,
- 0x3, 0x2, 0x2, 0x2, 0x3f9, 0x3fa, 0x3, 0x2, 0x2,
- 0x2, 0x3fa, 0x3fb, 0x3, 0x2, 0x2, 0x2, 0x3fb, 0x3fc,
- 0x7, 0xc, 0x2, 0x2, 0x3fc, 0x75, 0x3, 0x2, 0x2,
- 0x2, 0x3fd, 0x3ff, 0x7, 0x5, 0x2, 0x2, 0x3fe, 0x400,
- 0x7, 0x71, 0x2, 0x2, 0x3ff, 0x3fe, 0x3, 0x2, 0x2,
- 0x2, 0x3ff, 0x400, 0x3, 0x2, 0x2, 0x2, 0x400, 0x401,
- 0x3, 0x2, 0x2, 0x2, 0x401, 0x421, 0x5, 0x62, 0x32,
- 0x2, 0x402, 0x404, 0x7, 0x16, 0x2, 0x2, 0x403, 0x405,
- 0x7, 0x71, 0x2, 0x2, 0x404, 0x403, 0x3, 0x2, 0x2,
- 0x2, 0x404, 0x405, 0x3, 0x2, 0x2, 0x2, 0x405, 0x406,
- 0x3, 0x2, 0x2, 0x2, 0x406, 0x421, 0x5, 0x62, 0x32,
- 0x2, 0x407, 0x409, 0x7, 0x17, 0x2, 0x2, 0x408, 0x40a,
- 0x7, 0x71, 0x2, 0x2, 0x409, 0x408, 0x3, 0x2, 0x2,
- 0x2, 0x409, 0x40a, 0x3, 0x2, 0x2, 0x2, 0x40a, 0x40b,
- 0x3, 0x2, 0x2, 0x2, 0x40b, 0x421, 0x5, 0x62, 0x32,
- 0x2, 0x40c, 0x40e, 0x7, 0x18, 0x2, 0x2, 0x40d, 0x40f,
- 0x7, 0x71, 0x2, 0x2, 0x40e, 0x40d, 0x3, 0x2, 0x2,
- 0x2, 0x40e, 0x40f, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x410,
- 0x3, 0x2, 0x2, 0x2, 0x410, 0x421, 0x5, 0x62, 0x32,
- 0x2, 0x411, 0x413, 0x7, 0x19, 0x2, 0x2, 0x412, 0x414,
- 0x7, 0x71, 0x2, 0x2, 0x413, 0x412, 0x3, 0x2, 0x2,
- 0x2, 0x413, 0x414, 0x3, 0x2, 0x2, 0x2, 0x414, 0x415,
- 0x3, 0x2, 0x2, 0x2, 0x415, 0x421, 0x5, 0x62, 0x32,
- 0x2, 0x416, 0x418, 0x7, 0x1a, 0x2, 0x2, 0x417, 0x419,
- 0x7, 0x71, 0x2, 0x2, 0x418, 0x417, 0x3, 0x2, 0x2,
- 0x2, 0x418, 0x419, 0x3, 0x2, 0x2, 0x2, 0x419, 0x41a,
- 0x3, 0x2, 0x2, 0x2, 0x41a, 0x421, 0x5, 0x62, 0x32,
- 0x2, 0x41b, 0x41d, 0x7, 0x1b, 0x2, 0x2, 0x41c, 0x41e,
- 0x7, 0x71, 0x2, 0x2, 0x41d, 0x41c, 0x3, 0x2, 0x2,
- 0x2, 0x41d, 0x41e, 0x3, 0x2, 0x2, 0x2, 0x41e, 0x41f,
- 0x3, 0x2, 0x2, 0x2, 0x41f, 0x421, 0x5, 0x62, 0x32,
- 0x2, 0x420, 0x3fd, 0x3, 0x2, 0x2, 0x2, 0x420, 0x402,
- 0x3, 0x2, 0x2, 0x2, 0x420, 0x407, 0x3, 0x2, 0x2,
- 0x2, 0x420, 0x40c, 0x3, 0x2, 0x2, 0x2, 0x420, 0x411,
- 0x3, 0x2, 0x2, 0x2, 0x420, 0x416, 0x3, 0x2, 0x2,
- 0x2, 0x420, 0x41b, 0x3, 0x2, 0x2, 0x2, 0x421, 0x77,
- 0x3, 0x2, 0x2, 0x2, 0x422, 0x424, 0x7, 0x8, 0x2,
- 0x2, 0x423, 0x425, 0x7, 0x71, 0x2, 0x2, 0x424, 0x423,
- 0x3, 0x2, 0x2, 0x2, 0x424, 0x425, 0x3, 0x2, 0x2,
- 0x2, 0x425, 0x426, 0x3, 0x2, 0x2, 0x2, 0x426, 0x428,
- 0x5, 0x56, 0x2c, 0x2, 0x427, 0x429, 0x7, 0x71, 0x2,
- 0x2, 0x428, 0x427, 0x3, 0x2, 0x2, 0x2, 0x428, 0x429,
- 0x3, 0x2, 0x2, 0x2, 0x429, 0x42a, 0x3, 0x2, 0x2,
- 0x2, 0x42a, 0x42b, 0x7, 0x9, 0x2, 0x2, 0x42b, 0x79,
- 0x3, 0x2, 0x2, 0x2, 0x42c, 0x431, 0x5, 0x40, 0x21,
- 0x2, 0x42d, 0x42f, 0x7, 0x71, 0x2, 0x2, 0x42e, 0x42d,
- 0x3, 0x2, 0x2, 0x2, 0x42e, 0x42f, 0x3, 0x2, 0x2,
- 0x2, 0x42f, 0x430, 0x3, 0x2, 0x2, 0x2, 0x430, 0x432,
- 0x5, 0x42, 0x22, 0x2, 0x431, 0x42e, 0x3, 0x2, 0x2,
- 0x2, 0x432, 0x433, 0x3, 0x2, 0x2, 0x2, 0x433, 0x431,
- 0x3, 0x2, 0x2, 0x2, 0x433, 0x434, 0x3, 0x2, 0x2,
- 0x2, 0x434, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x435, 0x43a,
- 0x5, 0x7e, 0x40, 0x2, 0x436, 0x438, 0x7, 0x71, 0x2,
- 0x2, 0x437, 0x436, 0x3, 0x2, 0x2, 0x2, 0x437, 0x438,
- 0x3, 0x2, 0x2, 0x2, 0x438, 0x439, 0x3, 0x2, 0x2,
- 0x2, 0x439, 0x43b, 0x5, 0x36, 0x1c, 0x2, 0x43a, 0x437,
- 0x3, 0x2, 0x2, 0x2, 0x43a, 0x43b, 0x3, 0x2, 0x2,
- 0x2, 0x43b, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x43c, 0x43d,
- 0x5, 0x88, 0x45, 0x2, 0x43d, 0x43e, 0x7, 0x71, 0x2,
- 0x2, 0x43e, 0x43f, 0x7, 0x5f, 0x2, 0x2, 0x43f, 0x440,
- 0x7, 0x71, 0x2, 0x2, 0x440, 0x441, 0x5, 0x56, 0x2c,
- 0x2, 0x441, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x442, 0x444,
- 0x5, 0x82, 0x42, 0x2, 0x443, 0x445, 0x7, 0x71, 0x2,
- 0x2, 0x444, 0x443, 0x3, 0x2, 0x2, 0x2, 0x444, 0x445,
- 0x3, 0x2, 0x2, 0x2, 0x445, 0x446, 0x3, 0x2, 0x2,
- 0x2, 0x446, 0x448, 0x7, 0x8, 0x2, 0x2, 0x447, 0x449,
- 0x7, 0x71, 0x2, 0x2, 0x448, 0x447, 0x3, 0x2, 0x2,
- 0x2, 0x448, 0x449, 0x3, 0x2, 0x2, 0x2, 0x449, 0x44e,
- 0x3, 0x2, 0x2, 0x2, 0x44a, 0x44c, 0x7, 0x50, 0x2,
- 0x2, 0x44b, 0x44d, 0x7, 0x71, 0x2, 0x2, 0x44c, 0x44b,
- 0x3, 0x2, 0x2, 0x2, 0x44c, 0x44d, 0x3, 0x2, 0x2,
- 0x2, 0x44d, 0x44f, 0x3, 0x2, 0x2, 0x2, 0x44e, 0x44a,
- 0x3, 0x2, 0x2, 0x2, 0x44e, 0x44f, 0x3, 0x2, 0x2,
- 0x2, 0x44f, 0x461, 0x3, 0x2, 0x2, 0x2, 0x450, 0x452,
- 0x5, 0x56, 0x2c, 0x2, 0x451, 0x453, 0x7, 0x71, 0x2,
- 0x2, 0x452, 0x451, 0x3, 0x2, 0x2, 0x2, 0x452, 0x453,
- 0x3, 0x2, 0x2, 0x2, 0x453, 0x45e, 0x3, 0x2, 0x2,
- 0x2, 0x454, 0x456, 0x7, 0x4, 0x2, 0x2, 0x455, 0x457,
- 0x7, 0x71, 0x2, 0x2, 0x456, 0x455, 0x3, 0x2, 0x2,
- 0x2, 0x456, 0x457, 0x3, 0x2, 0x2, 0x2, 0x457, 0x458,
- 0x3, 0x2, 0x2, 0x2, 0x458, 0x45a, 0x5, 0x56, 0x2c,
- 0x2, 0x459, 0x45b, 0x7, 0x71, 0x2, 0x2, 0x45a, 0x459,
- 0x3, 0x2, 0x2, 0x2, 0x45a, 0x45b, 0x3, 0x2, 0x2,
- 0x2, 0x45b, 0x45d, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x454,
- 0x3, 0x2, 0x2, 0x2, 0x45d, 0x460, 0x3, 0x2, 0x2,
- 0x2, 0x45e, 0x45c, 0x3, 0x2, 0x2, 0x2, 0x45e, 0x45f,
- 0x3, 0x2, 0x2, 0x2, 0x45f, 0x462, 0x3, 0x2, 0x2,
- 0x2, 0x460, 0x45e, 0x3, 0x2, 0x2, 0x2, 0x461, 0x450,
- 0x3, 0x2, 0x2, 0x2, 0x461, 0x462, 0x3, 0x2, 0x2,
- 0x2, 0x462, 0x463, 0x3, 0x2, 0x2, 0x2, 0x463, 0x464,
- 0x7, 0x9, 0x2, 0x2, 0x464, 0x81, 0x3, 0x2, 0x2,
- 0x2, 0x465, 0x466, 0x9, 0x5, 0x2, 0x2, 0x466, 0x83,
- 0x3, 0x2, 0x2, 0x2, 0x467, 0x469, 0x7, 0xa, 0x2,
- 0x2, 0x468, 0x46a, 0x7, 0x71, 0x2, 0x2, 0x469, 0x468,
- 0x3, 0x2, 0x2, 0x2, 0x469, 0x46a, 0x3, 0x2, 0x2,
- 0x2, 0x46a, 0x46b, 0x3, 0x2, 0x2, 0x2, 0x46b, 0x474,
- 0x5, 0x7c, 0x3f, 0x2, 0x46c, 0x46e, 0x7, 0x71, 0x2,
- 0x2, 0x46d, 0x46c, 0x3, 0x2, 0x2, 0x2, 0x46d, 0x46e,
- 0x3, 0x2, 0x2, 0x2, 0x46e, 0x46f, 0x3, 0x2, 0x2,
- 0x2, 0x46f, 0x471, 0x7, 0xe, 0x2, 0x2, 0x470, 0x472,
- 0x7, 0x71, 0x2, 0x2, 0x471, 0x470, 0x3, 0x2, 0x2,
- 0x2, 0x471, 0x472, 0x3, 0x2, 0x2, 0x2, 0x472, 0x473,
- 0x3, 0x2, 0x2, 0x2, 0x473, 0x475, 0x5, 0x56, 0x2c,
- 0x2, 0x474, 0x46d, 0x3, 0x2, 0x2, 0x2, 0x474, 0x475,
- 0x3, 0x2, 0x2, 0x2, 0x475, 0x477, 0x3, 0x2, 0x2,
- 0x2, 0x476, 0x478, 0x7, 0x71, 0x2, 0x2, 0x477, 0x476,
- 0x3, 0x2, 0x2, 0x2, 0x477, 0x478, 0x3, 0x2, 0x2,
- 0x2, 0x478, 0x479, 0x3, 0x2, 0x2, 0x2, 0x479, 0x47a,
- 0x7, 0xc, 0x2, 0x2, 0x47a, 0x85, 0x3, 0x2, 0x2,
- 0x2, 0x47b, 0x47d, 0x7, 0x71, 0x2, 0x2, 0x47c, 0x47b,
- 0x3, 0x2, 0x2, 0x2, 0x47c, 0x47d, 0x3, 0x2, 0x2,
- 0x2, 0x47d, 0x47e, 0x3, 0x2, 0x2, 0x2, 0x47e, 0x480,
- 0x7, 0x1c, 0x2, 0x2, 0x47f, 0x481, 0x7, 0x71, 0x2,
- 0x2, 0x480, 0x47f, 0x3, 0x2, 0x2, 0x2, 0x480, 0x481,
- 0x3, 0x2, 0x2, 0x2, 0x481, 0x486, 0x3, 0x2, 0x2,
- 0x2, 0x482, 0x483, 0x5, 0x92, 0x4a, 0x2, 0x483, 0x484,
- 0x9, 0x6, 0x2, 0x2, 0x484, 0x487, 0x3, 0x2, 0x2,
- 0x2, 0x485, 0x487, 0x5, 0x92, 0x4a, 0x2, 0x486, 0x482,
- 0x3, 0x2, 0x2, 0x2, 0x486, 0x485, 0x3, 0x2, 0x2,
- 0x2, 0x487, 0x87, 0x3, 0x2, 0x2, 0x2, 0x488, 0x489,
- 0x5, 0x98, 0x4d, 0x2, 0x489, 0x89, 0x3, 0x2, 0x2,
- 0x2, 0x48a, 0x48d, 0x5, 0x96, 0x4c, 0x2, 0x48b, 0x48d,
- 0x5, 0x94, 0x4b, 0x2, 0x48c, 0x48a, 0x3, 0x2, 0x2,
- 0x2, 0x48c, 0x48b, 0x3, 0x2, 0x2, 0x2, 0x48d, 0x8b,
- 0x3, 0x2, 0x2, 0x2, 0x48e, 0x490, 0x7, 0x1e, 0x2,
- 0x2, 0x48f, 0x491, 0x7, 0x71, 0x2, 0x2, 0x490, 0x48f,
- 0x3, 0x2, 0x2, 0x2, 0x490, 0x491, 0x3, 0x2, 0x2,
- 0x2, 0x491, 0x4b3, 0x3, 0x2, 0x2, 0x2, 0x492, 0x494,
- 0x5, 0x92, 0x4a, 0x2, 0x493, 0x495, 0x7, 0x71, 0x2,
- 0x2, 0x494, 0x493, 0x3, 0x2, 0x2, 0x2, 0x494, 0x495,
- 0x3, 0x2, 0x2, 0x2, 0x495, 0x496, 0x3, 0x2, 0x2,
- 0x2, 0x496, 0x498, 0x7, 0xd, 0x2, 0x2, 0x497, 0x499,
- 0x7, 0x71, 0x2, 0x2, 0x498, 0x497, 0x3, 0x2, 0x2,
- 0x2, 0x498, 0x499, 0x3, 0x2, 0x2, 0x2, 0x499, 0x49a,
- 0x3, 0x2, 0x2, 0x2, 0x49a, 0x49c, 0x5, 0x56, 0x2c,
- 0x2, 0x49b, 0x49d, 0x7, 0x71, 0x2, 0x2, 0x49c, 0x49b,
- 0x3, 0x2, 0x2, 0x2, 0x49c, 0x49d, 0x3, 0x2, 0x2,
- 0x2, 0x49d, 0x4b0, 0x3, 0x2, 0x2, 0x2, 0x49e, 0x4a0,
- 0x7, 0x4, 0x2, 0x2, 0x49f, 0x4a1, 0x7, 0x71, 0x2,
- 0x2, 0x4a0, 0x49f, 0x3, 0x2, 0x2, 0x2, 0x4a0, 0x4a1,
- 0x3, 0x2, 0x2, 0x2, 0x4a1, 0x4a2, 0x3, 0x2, 0x2,
- 0x2, 0x4a2, 0x4a4, 0x5, 0x92, 0x4a, 0x2, 0x4a3, 0x4a5,
- 0x7, 0x71, 0x2, 0x2, 0x4a4, 0x4a3, 0x3, 0x2, 0x2,
- 0x2, 0x4a4, 0x4a5, 0x3, 0x2, 0x2, 0x2, 0x4a5, 0x4a6,
- 0x3, 0x2, 0x2, 0x2, 0x4a6, 0x4a8, 0x7, 0xd, 0x2,
- 0x2, 0x4a7, 0x4a9, 0x7, 0x71, 0x2, 0x2, 0x4a8, 0x4a7,
- 0x3, 0x2, 0x2, 0x2, 0x4a8, 0x4a9, 0x3, 0x2, 0x2,
- 0x2, 0x4a9, 0x4aa, 0x3, 0x2, 0x2, 0x2, 0x4aa, 0x4ac,
- 0x5, 0x56, 0x2c, 0x2, 0x4ab, 0x4ad, 0x7, 0x71, 0x2,
- 0x2, 0x4ac, 0x4ab, 0x3, 0x2, 0x2, 0x2, 0x4ac, 0x4ad,
- 0x3, 0x2, 0x2, 0x2, 0x4ad, 0x4af, 0x3, 0x2, 0x2,
- 0x2, 0x4ae, 0x49e, 0x3, 0x2, 0x2, 0x2, 0x4af, 0x4b2,
- 0x3, 0x2, 0x2, 0x2, 0x4b0, 0x4ae, 0x3, 0x2, 0x2,
- 0x2, 0x4b0, 0x4b1, 0x3, 0x2, 0x2, 0x2, 0x4b1, 0x4b4,
- 0x3, 0x2, 0x2, 0x2, 0x4b2, 0x4b0, 0x3, 0x2, 0x2,
- 0x2, 0x4b3, 0x492, 0x3, 0x2, 0x2, 0x2, 0x4b3, 0x4b4,
- 0x3, 0x2, 0x2, 0x2, 0x4b4, 0x4b5, 0x3, 0x2, 0x2,
- 0x2, 0x4b5, 0x4b6, 0x7, 0x1f, 0x2, 0x2, 0x4b6, 0x8d,
- 0x3, 0x2, 0x2, 0x2, 0x4b7, 0x4ba, 0x7, 0x20, 0x2,
- 0x2, 0x4b8, 0x4bb, 0x5, 0x98, 0x4d, 0x2, 0x4b9, 0x4bb,
- 0x7, 0x37, 0x2, 0x2, 0x4ba, 0x4b8, 0x3, 0x2, 0x2,
- 0x2, 0x4ba, 0x4b9, 0x3, 0x2, 0x2, 0x2, 0x4bb, 0x8f,
- 0x3, 0x2, 0x2, 0x2, 0x4bc, 0x4c1, 0x5, 0x6e, 0x38,
- 0x2, 0x4bd, 0x4bf, 0x7, 0x71, 0x2, 0x2, 0x4be, 0x4bd,
- 0x3, 0x2, 0x2, 0x2, 0x4be, 0x4bf, 0x3, 0x2, 0x2,
- 0x2, 0x4bf, 0x4c0, 0x3, 0x2, 0x2, 0x2, 0x4c0, 0x4c2,
- 0x5, 0x86, 0x44, 0x2, 0x4c1, 0x4be, 0x3, 0x2, 0x2,
- 0x2, 0x4c2, 0x4c3, 0x3, 0x2, 0x2, 0x2, 0x4c3, 0x4c1,
- 0x3, 0x2, 0x2, 0x2, 0x4c3, 0x4c4, 0x3, 0x2, 0x2,
- 0x2, 0x4c4, 0x91, 0x3, 0x2, 0x2, 0x2, 0x4c5, 0x4c6,
- 0x5, 0x98, 0x4d, 0x2, 0x4c6, 0x93, 0x3, 0x2, 0x2,
- 0x2, 0x4c7, 0x4c8, 0x9, 0x7, 0x2, 0x2, 0x4c8, 0x95,
- 0x3, 0x2, 0x2, 0x2, 0x4c9, 0x4ca, 0x9, 0x8, 0x2,
- 0x2, 0x4ca, 0x97, 0x3, 0x2, 0x2, 0x2, 0x4cb, 0x4cc,
- 0x9, 0x9, 0x2, 0x2, 0x4cc, 0x99, 0x3, 0x2, 0x2,
- 0x2, 0x4cd, 0x4ce, 0x9, 0xa, 0x2, 0x2, 0x4ce, 0x9b,
- 0x3, 0x2, 0x2, 0x2, 0x4cf, 0x4d0, 0x9, 0xb, 0x2,
- 0x2, 0x4d0, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x4d1, 0x4d2,
- 0x9, 0xc, 0x2, 0x2, 0x4d2, 0x9f, 0x3, 0x2, 0x2,
- 0x2, 0xdd, 0xa1, 0xa5, 0xa8, 0xab, 0xb3, 0xb8, 0xbd,
- 0xc2, 0xc9, 0xce, 0xd1, 0xdc, 0xe0, 0xe4, 0xe8, 0xeb,
- 0xef, 0xf9, 0x100, 0x10d, 0x111, 0x11b, 0x12d, 0x131, 0x135,
- 0x139, 0x13d, 0x142, 0x149, 0x14d, 0x152, 0x159, 0x15d, 0x160,
- 0x165, 0x168, 0x16c, 0x16f, 0x177, 0x17b, 0x17f, 0x183, 0x187,
- 0x18c, 0x191, 0x195, 0x19a, 0x19d, 0x1a6, 0x1af, 0x1b4, 0x1c1,
- 0x1c4, 0x1cc, 0x1d0, 0x1d5, 0x1da, 0x1de, 0x1e3, 0x1e9, 0x1ee,
- 0x1f5, 0x1f9, 0x1fd, 0x1ff, 0x203, 0x205, 0x209, 0x20b, 0x211,
- 0x217, 0x21b, 0x21e, 0x221, 0x225, 0x22b, 0x22f, 0x232, 0x235,
- 0x23b, 0x23e, 0x241, 0x245, 0x24b, 0x24e, 0x251, 0x255, 0x259,
- 0x25c, 0x25f, 0x262, 0x265, 0x26b, 0x270, 0x274, 0x277, 0x27c,
- 0x281, 0x286, 0x28e, 0x292, 0x294, 0x298, 0x29c, 0x29e, 0x2a0,
- 0x2af, 0x2b9, 0x2c3, 0x2c8, 0x2cc, 0x2d3, 0x2d8, 0x2dd, 0x2e1,
- 0x2e5, 0x2e9, 0x2ec, 0x2ee, 0x2f3, 0x2f7, 0x2fb, 0x2ff, 0x303,
- 0x307, 0x30a, 0x30c, 0x311, 0x315, 0x31a, 0x31f, 0x323, 0x32a,
- 0x331, 0x335, 0x339, 0x33d, 0x34c, 0x34f, 0x35c, 0x35e, 0x364,
- 0x366, 0x36d, 0x371, 0x375, 0x37b, 0x37f, 0x383, 0x389, 0x38d,
- 0x391, 0x394, 0x398, 0x39e, 0x3a2, 0x3a6, 0x3ac, 0x3b0, 0x3b4,
- 0x3ba, 0x3be, 0x3c2, 0x3c8, 0x3cc, 0x3d0, 0x3d8, 0x3e0, 0x3e6,
- 0x3ea, 0x3ee, 0x3f2, 0x3f6, 0x3f9, 0x3ff, 0x404, 0x409, 0x40e,
- 0x413, 0x418, 0x41d, 0x420, 0x424, 0x428, 0x42e, 0x433, 0x437,
- 0x43a, 0x444, 0x448, 0x44c, 0x44e, 0x452, 0x456, 0x45a, 0x45e,
- 0x461, 0x469, 0x46d, 0x471, 0x474, 0x477, 0x47c, 0x480, 0x486,
- 0x48c, 0x490, 0x494, 0x498, 0x49c, 0x4a0, 0x4a4, 0x4a8, 0x4ac,
- 0x4b0, 0x4b3, 0x4ba, 0x4be, 0x4c3,
+ 0x3, 0x430, 0xd6d1, 0x8206, 0xad2d, 0x4417, 0xaef1, 0x8d80, 0xaadd,
+ 0x3, 0x71, 0x522, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4,
+ 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7,
+ 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb,
+ 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe,
+ 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4,
+ 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15,
+ 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9,
+ 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b,
+ 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4,
+ 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22,
+ 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9,
+ 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28,
+ 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4,
+ 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f,
+ 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9,
+ 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35,
+ 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4,
+ 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c,
+ 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9,
+ 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42,
+ 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4,
+ 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49,
+ 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9,
+ 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f,
+ 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x3, 0x2, 0x5, 0x2, 0xa4,
+ 0xa, 0x2, 0x3, 0x2, 0x3, 0x2, 0x5, 0x2, 0xa8, 0xa, 0x2, 0x3, 0x2, 0x5,
+ 0x2, 0xab, 0xa, 0x2, 0x3, 0x2, 0x5, 0x2, 0xae, 0xa, 0x2, 0x3, 0x3, 0x3,
+ 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0xb6, 0xa, 0x5,
+ 0x3, 0x5, 0x7, 0x5, 0xb9, 0xa, 0x5, 0xc, 0x5, 0xe, 0x5, 0xbc, 0xb, 0x5,
+ 0x3, 0x6, 0x3, 0x6, 0x5, 0x6, 0xc0, 0xa, 0x6, 0x3, 0x6, 0x7, 0x6, 0xc3,
+ 0xa, 0x6, 0xc, 0x6, 0xe, 0x6, 0xc6, 0xb, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3,
+ 0x7, 0x3, 0x7, 0x5, 0x7, 0xcc, 0xa, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7,
+ 0x5, 0x7, 0xd1, 0xa, 0x7, 0x3, 0x7, 0x5, 0x7, 0xd4, 0xa, 0x7, 0x3, 0x8,
+ 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8,
+ 0x3, 0x8, 0x5, 0x8, 0xdf, 0xa, 0x8, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0xe3,
+ 0xa, 0x9, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0xe7, 0xa, 0x9, 0x3, 0x9, 0x3,
+ 0x9, 0x5, 0x9, 0xeb, 0xa, 0x9, 0x3, 0x9, 0x5, 0x9, 0xee, 0xa, 0x9, 0x3,
+ 0xa, 0x3, 0xa, 0x5, 0xa, 0xf2, 0xa, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa,
+ 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x5, 0xb, 0xfc, 0xa,
+ 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x101, 0xa, 0xb, 0xc, 0xb,
+ 0xe, 0xb, 0x104, 0xb, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3,
+ 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x110,
+ 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0x114, 0xa, 0xd, 0x3, 0xd, 0x3,
+ 0xd, 0x3, 0xe, 0x3, 0xe, 0x5, 0xe, 0x11a, 0xa, 0xe, 0x3, 0xe, 0x3, 0xe,
+ 0x3, 0xe, 0x7, 0xe, 0x11f, 0xa, 0xe, 0xc, 0xe, 0xe, 0xe, 0x122, 0xb,
+ 0xe, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x126, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf,
+ 0x5, 0xf, 0x12a, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5,
+ 0xf, 0x130, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x134, 0xa, 0xf,
+ 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x13a, 0xa, 0xf, 0x3,
+ 0xf, 0x3, 0xf, 0x5, 0xf, 0x13e, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf,
+ 0x3, 0xf, 0x5, 0xf, 0x144, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x5, 0xf, 0x148,
+ 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x14c, 0xa, 0x10, 0x3, 0x10,
+ 0x3, 0x10, 0x5, 0x10, 0x150, 0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10,
+ 0x154, 0xa, 0x10, 0x3, 0x10, 0x3, 0x10, 0x5, 0x10, 0x158, 0xa, 0x10,
+ 0x3, 0x10, 0x7, 0x10, 0x15b, 0xa, 0x10, 0xc, 0x10, 0xe, 0x10, 0x15e,
+ 0xb, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x164,
+ 0xa, 0x11, 0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0x168, 0xa, 0x11, 0x3, 0x11,
+ 0x7, 0x11, 0x16b, 0xa, 0x11, 0xc, 0x11, 0xe, 0x11, 0x16e, 0xb, 0x11,
+ 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0x174, 0xa, 0x12,
+ 0x3, 0x13, 0x3, 0x13, 0x5, 0x13, 0x178, 0xa, 0x13, 0x3, 0x13, 0x5, 0x13,
+ 0x17b, 0xa, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x5, 0x13, 0x180,
+ 0xa, 0x13, 0x3, 0x13, 0x5, 0x13, 0x183, 0xa, 0x13, 0x3, 0x14, 0x3, 0x14,
+ 0x5, 0x14, 0x187, 0xa, 0x14, 0x3, 0x14, 0x5, 0x14, 0x18a, 0xa, 0x14,
+ 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x5,
+ 0x15, 0x192, 0xa, 0x15, 0x3, 0x15, 0x3, 0x15, 0x5, 0x15, 0x196, 0xa,
+ 0x15, 0x3, 0x15, 0x3, 0x15, 0x5, 0x15, 0x19a, 0xa, 0x15, 0x3, 0x16,
+ 0x3, 0x16, 0x5, 0x16, 0x19e, 0xa, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16,
+ 0x1a2, 0xa, 0x16, 0x3, 0x16, 0x7, 0x16, 0x1a5, 0xa, 0x16, 0xc, 0x16,
+ 0xe, 0x16, 0x1a8, 0xb, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16, 0x1ac,
+ 0xa, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16, 0x1b0, 0xa, 0x16, 0x3, 0x16,
+ 0x7, 0x16, 0x1b3, 0xa, 0x16, 0xc, 0x16, 0xe, 0x16, 0x1b6, 0xb, 0x16,
+ 0x5, 0x16, 0x1b8, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17,
+ 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0x1c1, 0xa, 0x17, 0x3, 0x18,
+ 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5,
+ 0x18, 0x1ca, 0xa, 0x18, 0x3, 0x18, 0x7, 0x18, 0x1cd, 0xa, 0x18, 0xc,
+ 0x18, 0xe, 0x18, 0x1d0, 0xb, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19,
+ 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3,
+ 0x1b, 0x5, 0x1b, 0x1dc, 0xa, 0x1b, 0x3, 0x1b, 0x5, 0x1b, 0x1df, 0xa,
+ 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d,
+ 0x5, 0x1d, 0x1e7, 0xa, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x1eb,
+ 0xa, 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0x1ee, 0xa, 0x1d, 0xc, 0x1d, 0xe, 0x1d,
+ 0x1f1, 0xb, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x1f5, 0xa, 0x1e,
+ 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x1f9, 0xa, 0x1e, 0x3, 0x1e, 0x3, 0x1e,
+ 0x3, 0x1e, 0x5, 0x1e, 0x1fe, 0xa, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20,
+ 0x3, 0x20, 0x5, 0x20, 0x204, 0xa, 0x20, 0x3, 0x20, 0x7, 0x20, 0x207,
+ 0xa, 0x20, 0xc, 0x20, 0xe, 0x20, 0x20a, 0xb, 0x20, 0x3, 0x20, 0x3, 0x20,
+ 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 0x210, 0xa, 0x20, 0x3, 0x21, 0x3, 0x21,
+ 0x5, 0x21, 0x214, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x5, 0x21, 0x218,
+ 0xa, 0x21, 0x5, 0x21, 0x21a, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x5, 0x21,
+ 0x21e, 0xa, 0x21, 0x5, 0x21, 0x220, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21,
+ 0x5, 0x21, 0x224, 0xa, 0x21, 0x5, 0x21, 0x226, 0xa, 0x21, 0x3, 0x21,
+ 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x22c, 0xa, 0x22, 0x3, 0x22,
+ 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x232, 0xa, 0x23, 0x3, 0x23,
+ 0x3, 0x23, 0x5, 0x23, 0x236, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x239,
+ 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x23c, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23,
+ 0x5, 0x23, 0x240, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23,
+ 0x5, 0x23, 0x246, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x24a,
+ 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x24d, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23,
+ 0x250, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
+ 0x256, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x259, 0xa, 0x23, 0x3, 0x23,
+ 0x5, 0x23, 0x25c, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x260,
+ 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x266,
+ 0xa, 0x23, 0x3, 0x23, 0x5, 0x23, 0x269, 0xa, 0x23, 0x3, 0x23, 0x5, 0x23,
+ 0x26c, 0xa, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, 0x270, 0xa, 0x23,
+ 0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x274, 0xa, 0x24, 0x3, 0x24, 0x3, 0x24,
+ 0x5, 0x24, 0x278, 0xa, 0x24, 0x5, 0x24, 0x27a, 0xa, 0x24, 0x3, 0x24,
+ 0x3, 0x24, 0x5, 0x24, 0x27e, 0xa, 0x24, 0x5, 0x24, 0x280, 0xa, 0x24,
+ 0x3, 0x24, 0x5, 0x24, 0x283, 0xa, 0x24, 0x3, 0x24, 0x3, 0x24, 0x5, 0x24,
+ 0x287, 0xa, 0x24, 0x5, 0x24, 0x289, 0xa, 0x24, 0x3, 0x24, 0x3, 0x24,
+ 0x3, 0x25, 0x3, 0x25, 0x5, 0x25, 0x28f, 0xa, 0x25, 0x3, 0x26, 0x3, 0x26,
+ 0x5, 0x26, 0x293, 0xa, 0x26, 0x3, 0x26, 0x3, 0x26, 0x5, 0x26, 0x297,
+ 0xa, 0x26, 0x3, 0x26, 0x3, 0x26, 0x5, 0x26, 0x29b, 0xa, 0x26, 0x3, 0x26,
+ 0x5, 0x26, 0x29e, 0xa, 0x26, 0x3, 0x26, 0x7, 0x26, 0x2a1, 0xa, 0x26,
+ 0xc, 0x26, 0xe, 0x26, 0x2a4, 0xb, 0x26, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27,
+ 0x2a8, 0xa, 0x27, 0x3, 0x27, 0x7, 0x27, 0x2ab, 0xa, 0x27, 0xc, 0x27,
+ 0xe, 0x27, 0x2ae, 0xb, 0x27, 0x3, 0x28, 0x3, 0x28, 0x5, 0x28, 0x2b2,
+ 0xa, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2b8,
+ 0xa, 0x29, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2bc, 0xa, 0x29, 0x5, 0x29,
+ 0x2be, 0xa, 0x29, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2c2, 0xa, 0x29,
+ 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2c6, 0xa, 0x29, 0x5, 0x29, 0x2c8,
+ 0xa, 0x29, 0x5, 0x29, 0x2ca, 0xa, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b,
+ 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3,
+ 0x2d, 0x3, 0x2d, 0x7, 0x2d, 0x2d7, 0xa, 0x2d, 0xc, 0x2d, 0xe, 0x2d,
+ 0x2da, 0xb, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e,
+ 0x7, 0x2e, 0x2e1, 0xa, 0x2e, 0xc, 0x2e, 0xe, 0x2e, 0x2e4, 0xb, 0x2e,
+ 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x7, 0x2f, 0x2eb,
+ 0xa, 0x2f, 0xc, 0x2f, 0xe, 0x2f, 0x2ee, 0xb, 0x2f, 0x3, 0x30, 0x3, 0x30,
+ 0x5, 0x30, 0x2f2, 0xa, 0x30, 0x7, 0x30, 0x2f4, 0xa, 0x30, 0xc, 0x30,
+ 0xe, 0x30, 0x2f7, 0xb, 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31,
+ 0x5, 0x31, 0x2fd, 0xa, 0x31, 0x3, 0x31, 0x7, 0x31, 0x300, 0xa, 0x31,
+ 0xc, 0x31, 0xe, 0x31, 0x303, 0xb, 0x31, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32,
+ 0x307, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x30b, 0xa, 0x32,
+ 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x30f, 0xa, 0x32, 0x3, 0x32, 0x3, 0x32,
+ 0x5, 0x32, 0x313, 0xa, 0x32, 0x3, 0x32, 0x7, 0x32, 0x316, 0xa, 0x32,
+ 0xc, 0x32, 0xe, 0x32, 0x319, 0xb, 0x32, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33,
+ 0x31d, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x321, 0xa, 0x33,
+ 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x325, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33,
+ 0x5, 0x33, 0x329, 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x32d,
+ 0xa, 0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x331, 0xa, 0x33, 0x3, 0x33,
+ 0x7, 0x33, 0x334, 0xa, 0x33, 0xc, 0x33, 0xe, 0x33, 0x337, 0xb, 0x33,
+ 0x3, 0x34, 0x3, 0x34, 0x5, 0x34, 0x33b, 0xa, 0x34, 0x3, 0x34, 0x3, 0x34,
+ 0x5, 0x34, 0x33f, 0xa, 0x34, 0x3, 0x34, 0x7, 0x34, 0x342, 0xa, 0x34,
+ 0xc, 0x34, 0xe, 0x34, 0x345, 0xb, 0x34, 0x3, 0x35, 0x3, 0x35, 0x5, 0x35,
+ 0x349, 0xa, 0x35, 0x7, 0x35, 0x34b, 0xa, 0x35, 0xc, 0x35, 0xe, 0x35,
+ 0x34e, 0xb, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36,
+ 0x354, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
+ 0x5, 0x36, 0x35b, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x35f,
+ 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x363, 0xa, 0x36, 0x3, 0x36,
+ 0x3, 0x36, 0x5, 0x36, 0x367, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
+ 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3,
+ 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x376, 0xa, 0x36,
+ 0x3, 0x36, 0x5, 0x36, 0x379, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36,
+ 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3,
+ 0x36, 0x3, 0x36, 0x7, 0x36, 0x386, 0xa, 0x36, 0xc, 0x36, 0xe, 0x36,
+ 0x389, 0xb, 0x36, 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x38d, 0xa, 0x37,
+ 0x3, 0x37, 0x3, 0x37, 0x5, 0x37, 0x391, 0xa, 0x37, 0x7, 0x37, 0x393,
+ 0xa, 0x37, 0xc, 0x37, 0xe, 0x37, 0x396, 0xb, 0x37, 0x3, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x39c, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38,
+ 0x5, 0x38, 0x3a0, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3a4,
+ 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5,
+ 0x38, 0x3ab, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3af, 0xa,
+ 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3b3, 0xa, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3b9, 0xa, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x5, 0x38, 0x3bd, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
+ 0x3c1, 0xa, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3c4, 0xa, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x5, 0x38, 0x3c8, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x5, 0x38, 0x3ce, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
+ 0x3d2, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3d6, 0xa, 0x38,
+ 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3dc, 0xa, 0x38,
+ 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3e0, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38,
+ 0x5, 0x38, 0x3e4, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
+ 0x5, 0x38, 0x3ea, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3ee,
+ 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3f2, 0xa, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38, 0x3f8, 0xa, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x5, 0x38, 0x3fc, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x5, 0x38,
+ 0x400, 0xa, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38,
+ 0x3, 0x38, 0x5, 0x38, 0x408, 0xa, 0x38, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39,
+ 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x5, 0x39, 0x410, 0xa, 0x39, 0x3, 0x3a,
+ 0x3, 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x416, 0xa, 0x3b, 0x3, 0x3b,
+ 0x3, 0x3b, 0x5, 0x3b, 0x41a, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b,
+ 0x41e, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, 0x422, 0xa, 0x3b,
+ 0x7, 0x3b, 0x424, 0xa, 0x3b, 0xc, 0x3b, 0xe, 0x3b, 0x427, 0xb, 0x3b,
+ 0x5, 0x3b, 0x429, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3c, 0x3, 0x3c,
+ 0x5, 0x3c, 0x42f, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c,
+ 0x434, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x439,
+ 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x43e, 0xa, 0x3c,
+ 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x443, 0xa, 0x3c, 0x3, 0x3c,
+ 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x448, 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c,
+ 0x3, 0x3c, 0x5, 0x3c, 0x44d, 0xa, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x450,
+ 0xa, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x454, 0xa, 0x3d, 0x3, 0x3d,
+ 0x3, 0x3d, 0x5, 0x3d, 0x458, 0xa, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3e,
+ 0x3, 0x3e, 0x5, 0x3e, 0x45e, 0xa, 0x3e, 0x3, 0x3e, 0x6, 0x3e, 0x461,
+ 0xa, 0x3e, 0xd, 0x3e, 0xe, 0x3e, 0x462, 0x3, 0x3f, 0x3, 0x3f, 0x5, 0x3f,
+ 0x467, 0xa, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x46a, 0xa, 0x3f, 0x3, 0x40,
+ 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, 0x3, 0x41, 0x3,
+ 0x41, 0x5, 0x41, 0x474, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41,
+ 0x478, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x47c, 0xa, 0x41,
+ 0x5, 0x41, 0x47e, 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x482,
+ 0xa, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, 0x486, 0xa, 0x41, 0x3, 0x41,
+ 0x3, 0x41, 0x5, 0x41, 0x48a, 0xa, 0x41, 0x7, 0x41, 0x48c, 0xa, 0x41,
+ 0xc, 0x41, 0xe, 0x41, 0x48f, 0xb, 0x41, 0x5, 0x41, 0x491, 0xa, 0x41,
+ 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, 0x5,
+ 0x43, 0x499, 0xa, 0x43, 0x3, 0x43, 0x3, 0x43, 0x5, 0x43, 0x49d, 0xa,
+ 0x43, 0x3, 0x43, 0x3, 0x43, 0x5, 0x43, 0x4a1, 0xa, 0x43, 0x3, 0x43,
+ 0x5, 0x43, 0x4a4, 0xa, 0x43, 0x3, 0x43, 0x5, 0x43, 0x4a7, 0xa, 0x43,
+ 0x3, 0x43, 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4ad, 0xa, 0x44,
+ 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4b1, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44,
+ 0x5, 0x44, 0x4b5, 0xa, 0x44, 0x5, 0x44, 0x4b7, 0xa, 0x44, 0x3, 0x44,
+ 0x3, 0x44, 0x5, 0x44, 0x4bb, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44,
+ 0x4bf, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4c3, 0xa, 0x44,
+ 0x5, 0x44, 0x4c5, 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4c9,
+ 0xa, 0x44, 0x3, 0x44, 0x3, 0x44, 0x5, 0x44, 0x4cd, 0xa, 0x44, 0x3, 0x44,
+ 0x3, 0x44, 0x3, 0x45, 0x3, 0x45, 0x5, 0x45, 0x4d3, 0xa, 0x45, 0x3, 0x45,
+ 0x3, 0x45, 0x3, 0x46, 0x3, 0x46, 0x3, 0x47, 0x3, 0x47, 0x5, 0x47, 0x4db,
+ 0xa, 0x47, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4df, 0xa, 0x48, 0x3, 0x48,
+ 0x3, 0x48, 0x5, 0x48, 0x4e3, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48,
+ 0x4e7, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4eb, 0xa, 0x48,
+ 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4ef, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48,
+ 0x5, 0x48, 0x4f3, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4f7,
+ 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x4fb, 0xa, 0x48, 0x7, 0x48,
+ 0x4fd, 0xa, 0x48, 0xc, 0x48, 0xe, 0x48, 0x500, 0xb, 0x48, 0x5, 0x48,
+ 0x502, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49,
+ 0x5, 0x49, 0x509, 0xa, 0x49, 0x3, 0x4a, 0x3, 0x4a, 0x5, 0x4a, 0x50d,
+ 0xa, 0x4a, 0x3, 0x4a, 0x6, 0x4a, 0x510, 0xa, 0x4a, 0xd, 0x4a, 0xe, 0x4a,
+ 0x511, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d,
+ 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3,
+ 0x51, 0x3, 0x51, 0x3, 0x51, 0x2, 0x2, 0x52, 0x2, 0x4, 0x6, 0x8, 0xa,
+ 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22,
+ 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a,
+ 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52,
+ 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a,
+ 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82,
+ 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a,
+ 0x9c, 0x9e, 0xa0, 0x2, 0xc, 0x3, 0x2, 0x54, 0x57, 0x3, 0x2, 0xf, 0x10,
+ 0x3, 0x2, 0x69, 0x6a, 0x5, 0x2, 0x63, 0x63, 0x6b, 0x6b, 0x6e, 0x6e,
+ 0x3, 0x2, 0x34, 0x36, 0x3, 0x2, 0x3e, 0x3f, 0x5, 0x2, 0x37, 0x37, 0x40,
+ 0x6b, 0x6e, 0x6e, 0x4, 0x2, 0x17, 0x17, 0x1f, 0x22, 0x4, 0x2, 0x18,
+ 0x18, 0x23, 0x26, 0x4, 0x2, 0x10, 0x10, 0x27, 0x31, 0x5ea, 0x2, 0xa3,
+ 0x3, 0x2, 0x2, 0x2, 0x4, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x6, 0xb1, 0x3, 0x2,
+ 0x2, 0x2, 0x8, 0xb3, 0x3, 0x2, 0x2, 0x2, 0xa, 0xbd, 0x3, 0x2, 0x2, 0x2,
+ 0xc, 0xd3, 0x3, 0x2, 0x2, 0x2, 0xe, 0xde, 0x3, 0x2, 0x2, 0x2, 0x10,
+ 0xe2, 0x3, 0x2, 0x2, 0x2, 0x12, 0xef, 0x3, 0x2, 0x2, 0x2, 0x14, 0xf9,
+ 0x3, 0x2, 0x2, 0x2, 0x16, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x18, 0x111, 0x3,
+ 0x2, 0x2, 0x2, 0x1a, 0x117, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x147, 0x3, 0x2,
+ 0x2, 0x2, 0x1e, 0x14b, 0x3, 0x2, 0x2, 0x2, 0x20, 0x15f, 0x3, 0x2, 0x2,
+ 0x2, 0x22, 0x173, 0x3, 0x2, 0x2, 0x2, 0x24, 0x175, 0x3, 0x2, 0x2, 0x2,
+ 0x26, 0x184, 0x3, 0x2, 0x2, 0x2, 0x28, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x2a,
+ 0x1b7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x1c0, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x1c2,
+ 0x3, 0x2, 0x2, 0x2, 0x30, 0x1d1, 0x3, 0x2, 0x2, 0x2, 0x32, 0x1d5, 0x3,
+ 0x2, 0x2, 0x2, 0x34, 0x1d9, 0x3, 0x2, 0x2, 0x2, 0x36, 0x1e0, 0x3, 0x2,
+ 0x2, 0x2, 0x38, 0x1e4, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x1fd, 0x3, 0x2, 0x2,
+ 0x2, 0x3c, 0x1ff, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x20f, 0x3, 0x2, 0x2, 0x2,
+ 0x40, 0x211, 0x3, 0x2, 0x2, 0x2, 0x42, 0x229, 0x3, 0x2, 0x2, 0x2, 0x44,
+ 0x26f, 0x3, 0x2, 0x2, 0x2, 0x46, 0x271, 0x3, 0x2, 0x2, 0x2, 0x48, 0x28e,
+ 0x3, 0x2, 0x2, 0x2, 0x4a, 0x290, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x2a5, 0x3,
+ 0x2, 0x2, 0x2, 0x4e, 0x2af, 0x3, 0x2, 0x2, 0x2, 0x50, 0x2b5, 0x3, 0x2,
+ 0x2, 0x2, 0x52, 0x2cb, 0x3, 0x2, 0x2, 0x2, 0x54, 0x2cd, 0x3, 0x2, 0x2,
+ 0x2, 0x56, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0x58, 0x2d1, 0x3, 0x2, 0x2, 0x2,
+ 0x5a, 0x2db, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x2e5, 0x3, 0x2, 0x2, 0x2, 0x5e,
+ 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x60, 0x2fa, 0x3, 0x2, 0x2, 0x2, 0x62, 0x304,
+ 0x3, 0x2, 0x2, 0x2, 0x64, 0x31a, 0x3, 0x2, 0x2, 0x2, 0x66, 0x338, 0x3,
+ 0x2, 0x2, 0x2, 0x68, 0x34c, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x351, 0x3, 0x2,
+ 0x2, 0x2, 0x6c, 0x38a, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x407, 0x3, 0x2, 0x2,
+ 0x2, 0x70, 0x40f, 0x3, 0x2, 0x2, 0x2, 0x72, 0x411, 0x3, 0x2, 0x2, 0x2,
+ 0x74, 0x413, 0x3, 0x2, 0x2, 0x2, 0x76, 0x44f, 0x3, 0x2, 0x2, 0x2, 0x78,
+ 0x451, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x45b, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x464,
+ 0x3, 0x2, 0x2, 0x2, 0x7e, 0x46b, 0x3, 0x2, 0x2, 0x2, 0x80, 0x471, 0x3,
+ 0x2, 0x2, 0x2, 0x82, 0x494, 0x3, 0x2, 0x2, 0x2, 0x84, 0x496, 0x3, 0x2,
+ 0x2, 0x2, 0x86, 0x4aa, 0x3, 0x2, 0x2, 0x2, 0x88, 0x4d0, 0x3, 0x2, 0x2,
+ 0x2, 0x8a, 0x4d6, 0x3, 0x2, 0x2, 0x2, 0x8c, 0x4da, 0x3, 0x2, 0x2, 0x2,
+ 0x8e, 0x4dc, 0x3, 0x2, 0x2, 0x2, 0x90, 0x505, 0x3, 0x2, 0x2, 0x2, 0x92,
+ 0x50a, 0x3, 0x2, 0x2, 0x2, 0x94, 0x513, 0x3, 0x2, 0x2, 0x2, 0x96, 0x515,
+ 0x3, 0x2, 0x2, 0x2, 0x98, 0x517, 0x3, 0x2, 0x2, 0x2, 0x9a, 0x519, 0x3,
+ 0x2, 0x2, 0x2, 0x9c, 0x51b, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x51d, 0x3, 0x2,
+ 0x2, 0x2, 0xa0, 0x51f, 0x3, 0x2, 0x2, 0x2, 0xa2, 0xa4, 0x7, 0x6f, 0x2,
+ 0x2, 0xa3, 0xa2, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x3, 0x2, 0x2, 0x2,
+ 0xa4, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xaa, 0x5, 0x4, 0x3, 0x2, 0xa6,
+ 0xa8, 0x7, 0x6f, 0x2, 0x2, 0xa7, 0xa6, 0x3, 0x2, 0x2, 0x2, 0xa7, 0xa8,
+ 0x3, 0x2, 0x2, 0x2, 0xa8, 0xa9, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xab, 0x7,
+ 0x3, 0x2, 0x2, 0xaa, 0xa7, 0x3, 0x2, 0x2, 0x2, 0xaa, 0xab, 0x3, 0x2,
+ 0x2, 0x2, 0xab, 0xad, 0x3, 0x2, 0x2, 0x2, 0xac, 0xae, 0x7, 0x6f, 0x2,
+ 0x2, 0xad, 0xac, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae, 0x3, 0x2, 0x2, 0x2,
+ 0xae, 0x3, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, 0x5, 0x6, 0x4, 0x2, 0xb0,
+ 0x5, 0x3, 0x2, 0x2, 0x2, 0xb1, 0xb2, 0x5, 0x8, 0x5, 0x2, 0xb2, 0x7,
+ 0x3, 0x2, 0x2, 0x2, 0xb3, 0xba, 0x5, 0xa, 0x6, 0x2, 0xb4, 0xb6, 0x7,
+ 0x6f, 0x2, 0x2, 0xb5, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb6, 0x3, 0x2,
+ 0x2, 0x2, 0xb6, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb9, 0x5, 0xc, 0x7,
+ 0x2, 0xb8, 0xb5, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xbc, 0x3, 0x2, 0x2, 0x2,
+ 0xba, 0xb8, 0x3, 0x2, 0x2, 0x2, 0xba, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbb,
+ 0x9, 0x3, 0x2, 0x2, 0x2, 0xbc, 0xba, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xc4,
+ 0x5, 0xe, 0x8, 0x2, 0xbe, 0xc0, 0x7, 0x6f, 0x2, 0x2, 0xbf, 0xbe, 0x3,
+ 0x2, 0x2, 0x2, 0xbf, 0xc0, 0x3, 0x2, 0x2, 0x2, 0xc0, 0xc1, 0x3, 0x2,
+ 0x2, 0x2, 0xc1, 0xc3, 0x5, 0xe, 0x8, 0x2, 0xc2, 0xbf, 0x3, 0x2, 0x2,
+ 0x2, 0xc3, 0xc6, 0x3, 0x2, 0x2, 0x2, 0xc4, 0xc2, 0x3, 0x2, 0x2, 0x2,
+ 0xc4, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xb, 0x3, 0x2, 0x2, 0x2, 0xc6,
+ 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc8, 0x7, 0x40, 0x2, 0x2, 0xc8, 0xc9,
+ 0x7, 0x6f, 0x2, 0x2, 0xc9, 0xcb, 0x7, 0x41, 0x2, 0x2, 0xca, 0xcc, 0x7,
+ 0x6f, 0x2, 0x2, 0xcb, 0xca, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xcc, 0x3, 0x2,
+ 0x2, 0x2, 0xcc, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xd4, 0x5, 0xa, 0x6,
+ 0x2, 0xce, 0xd0, 0x7, 0x40, 0x2, 0x2, 0xcf, 0xd1, 0x7, 0x6f, 0x2, 0x2,
+ 0xd0, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd0, 0xd1, 0x3, 0x2, 0x2, 0x2, 0xd1,
+ 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd2, 0xd4, 0x5, 0xa, 0x6, 0x2, 0xd3, 0xc7,
+ 0x3, 0x2, 0x2, 0x2, 0xd3, 0xce, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd, 0x3,
+ 0x2, 0x2, 0x2, 0xd5, 0xdf, 0x5, 0x10, 0x9, 0x2, 0xd6, 0xdf, 0x5, 0x12,
+ 0xa, 0x2, 0xd7, 0xdf, 0x5, 0x14, 0xb, 0x2, 0xd8, 0xdf, 0x5, 0x18, 0xd,
+ 0x2, 0xd9, 0xdf, 0x5, 0x1a, 0xe, 0x2, 0xda, 0xdf, 0x5, 0x1e, 0x10, 0x2,
+ 0xdb, 0xdf, 0x5, 0x20, 0x11, 0x2, 0xdc, 0xdf, 0x5, 0x24, 0x13, 0x2,
+ 0xdd, 0xdf, 0x5, 0x26, 0x14, 0x2, 0xde, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xde,
+ 0xd6, 0x3, 0x2, 0x2, 0x2, 0xde, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xde, 0xd8,
+ 0x3, 0x2, 0x2, 0x2, 0xde, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xde, 0xda, 0x3,
+ 0x2, 0x2, 0x2, 0xde, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdc, 0x3, 0x2,
+ 0x2, 0x2, 0xde, 0xdd, 0x3, 0x2, 0x2, 0x2, 0xdf, 0xf, 0x3, 0x2, 0x2,
+ 0x2, 0xe0, 0xe1, 0x7, 0x42, 0x2, 0x2, 0xe1, 0xe3, 0x7, 0x6f, 0x2, 0x2,
+ 0xe2, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe2, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe3,
+ 0xe4, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe6, 0x7, 0x43, 0x2, 0x2, 0xe5, 0xe7,
+ 0x7, 0x6f, 0x2, 0x2, 0xe6, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x3,
+ 0x2, 0x2, 0x2, 0xe7, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xe8, 0xed, 0x5, 0x38,
+ 0x1d, 0x2, 0xe9, 0xeb, 0x7, 0x6f, 0x2, 0x2, 0xea, 0xe9, 0x3, 0x2, 0x2,
+ 0x2, 0xea, 0xeb, 0x3, 0x2, 0x2, 0x2, 0xeb, 0xec, 0x3, 0x2, 0x2, 0x2,
+ 0xec, 0xee, 0x5, 0x36, 0x1c, 0x2, 0xed, 0xea, 0x3, 0x2, 0x2, 0x2, 0xed,
+ 0xee, 0x3, 0x2, 0x2, 0x2, 0xee, 0x11, 0x3, 0x2, 0x2, 0x2, 0xef, 0xf1,
+ 0x7, 0x44, 0x2, 0x2, 0xf0, 0xf2, 0x7, 0x6f, 0x2, 0x2, 0xf1, 0xf0, 0x3,
+ 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf3, 0x3, 0x2,
+ 0x2, 0x2, 0xf3, 0xf4, 0x5, 0x56, 0x2c, 0x2, 0xf4, 0xf5, 0x7, 0x6f, 0x2,
+ 0x2, 0xf5, 0xf6, 0x7, 0x45, 0x2, 0x2, 0xf6, 0xf7, 0x7, 0x6f, 0x2, 0x2,
+ 0xf7, 0xf8, 0x5, 0x8a, 0x46, 0x2, 0xf8, 0x13, 0x3, 0x2, 0x2, 0x2, 0xf9,
+ 0xfb, 0x7, 0x46, 0x2, 0x2, 0xfa, 0xfc, 0x7, 0x6f, 0x2, 0x2, 0xfb, 0xfa,
+ 0x3, 0x2, 0x2, 0x2, 0xfb, 0xfc, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x3,
+ 0x2, 0x2, 0x2, 0xfd, 0x102, 0x5, 0x3a, 0x1e, 0x2, 0xfe, 0xff, 0x7, 0x6f,
+ 0x2, 0x2, 0xff, 0x101, 0x5, 0x16, 0xc, 0x2, 0x100, 0xfe, 0x3, 0x2, 0x2,
+ 0x2, 0x101, 0x104, 0x3, 0x2, 0x2, 0x2, 0x102, 0x100, 0x3, 0x2, 0x2,
+ 0x2, 0x102, 0x103, 0x3, 0x2, 0x2, 0x2, 0x103, 0x15, 0x3, 0x2, 0x2, 0x2,
+ 0x104, 0x102, 0x3, 0x2, 0x2, 0x2, 0x105, 0x106, 0x7, 0x47, 0x2, 0x2,
+ 0x106, 0x107, 0x7, 0x6f, 0x2, 0x2, 0x107, 0x108, 0x7, 0x43, 0x2, 0x2,
+ 0x108, 0x109, 0x7, 0x6f, 0x2, 0x2, 0x109, 0x110, 0x5, 0x1a, 0xe, 0x2,
+ 0x10a, 0x10b, 0x7, 0x47, 0x2, 0x2, 0x10b, 0x10c, 0x7, 0x6f, 0x2, 0x2,
+ 0x10c, 0x10d, 0x7, 0x48, 0x2, 0x2, 0x10d, 0x10e, 0x7, 0x6f, 0x2, 0x2,
+ 0x10e, 0x110, 0x5, 0x1a, 0xe, 0x2, 0x10f, 0x105, 0x3, 0x2, 0x2, 0x2,
+ 0x10f, 0x10a, 0x3, 0x2, 0x2, 0x2, 0x110, 0x17, 0x3, 0x2, 0x2, 0x2, 0x111,
+ 0x113, 0x7, 0x48, 0x2, 0x2, 0x112, 0x114, 0x7, 0x6f, 0x2, 0x2, 0x113,
+ 0x112, 0x3, 0x2, 0x2, 0x2, 0x113, 0x114, 0x3, 0x2, 0x2, 0x2, 0x114,
+ 0x115, 0x3, 0x2, 0x2, 0x2, 0x115, 0x116, 0x5, 0x38, 0x1d, 0x2, 0x116,
+ 0x19, 0x3, 0x2, 0x2, 0x2, 0x117, 0x119, 0x7, 0x49, 0x2, 0x2, 0x118,
+ 0x11a, 0x7, 0x6f, 0x2, 0x2, 0x119, 0x118, 0x3, 0x2, 0x2, 0x2, 0x119,
+ 0x11a, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x3, 0x2, 0x2, 0x2, 0x11b,
+ 0x120, 0x5, 0x1c, 0xf, 0x2, 0x11c, 0x11d, 0x7, 0x4, 0x2, 0x2, 0x11d,
+ 0x11f, 0x5, 0x1c, 0xf, 0x2, 0x11e, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x11f,
+ 0x122, 0x3, 0x2, 0x2, 0x2, 0x120, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x120,
+ 0x121, 0x3, 0x2, 0x2, 0x2, 0x121, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x122, 0x120,
+ 0x3, 0x2, 0x2, 0x2, 0x123, 0x125, 0x5, 0x92, 0x4a, 0x2, 0x124, 0x126,
+ 0x7, 0x6f, 0x2, 0x2, 0x125, 0x124, 0x3, 0x2, 0x2, 0x2, 0x125, 0x126,
+ 0x3, 0x2, 0x2, 0x2, 0x126, 0x127, 0x3, 0x2, 0x2, 0x2, 0x127, 0x129,
+ 0x7, 0x5, 0x2, 0x2, 0x128, 0x12a, 0x7, 0x6f, 0x2, 0x2, 0x129, 0x128,
+ 0x3, 0x2, 0x2, 0x2, 0x129, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x12b,
+ 0x3, 0x2, 0x2, 0x2, 0x12b, 0x12c, 0x5, 0x56, 0x2c, 0x2, 0x12c, 0x148,
+ 0x3, 0x2, 0x2, 0x2, 0x12d, 0x12f, 0x5, 0x8a, 0x46, 0x2, 0x12e, 0x130,
+ 0x7, 0x6f, 0x2, 0x2, 0x12f, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x12f, 0x130,
+ 0x3, 0x2, 0x2, 0x2, 0x130, 0x131, 0x3, 0x2, 0x2, 0x2, 0x131, 0x133,
+ 0x7, 0x5, 0x2, 0x2, 0x132, 0x134, 0x7, 0x6f, 0x2, 0x2, 0x133, 0x132,
+ 0x3, 0x2, 0x2, 0x2, 0x133, 0x134, 0x3, 0x2, 0x2, 0x2, 0x134, 0x135,
+ 0x3, 0x2, 0x2, 0x2, 0x135, 0x136, 0x5, 0x56, 0x2c, 0x2, 0x136, 0x148,
+ 0x3, 0x2, 0x2, 0x2, 0x137, 0x139, 0x5, 0x8a, 0x46, 0x2, 0x138, 0x13a,
+ 0x7, 0x6f, 0x2, 0x2, 0x139, 0x138, 0x3, 0x2, 0x2, 0x2, 0x139, 0x13a,
+ 0x3, 0x2, 0x2, 0x2, 0x13a, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13d,
+ 0x7, 0x6, 0x2, 0x2, 0x13c, 0x13e, 0x7, 0x6f, 0x2, 0x2, 0x13d, 0x13c,
+ 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13f,
+ 0x3, 0x2, 0x2, 0x2, 0x13f, 0x140, 0x5, 0x56, 0x2c, 0x2, 0x140, 0x148,
+ 0x3, 0x2, 0x2, 0x2, 0x141, 0x143, 0x5, 0x8a, 0x46, 0x2, 0x142, 0x144,
+ 0x7, 0x6f, 0x2, 0x2, 0x143, 0x142, 0x3, 0x2, 0x2, 0x2, 0x143, 0x144,
+ 0x3, 0x2, 0x2, 0x2, 0x144, 0x145, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146,
+ 0x5, 0x4c, 0x27, 0x2, 0x146, 0x148, 0x3, 0x2, 0x2, 0x2, 0x147, 0x123,
+ 0x3, 0x2, 0x2, 0x2, 0x147, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x147, 0x137,
+ 0x3, 0x2, 0x2, 0x2, 0x147, 0x141, 0x3, 0x2, 0x2, 0x2, 0x148, 0x1d, 0x3,
+ 0x2, 0x2, 0x2, 0x149, 0x14a, 0x7, 0x4a, 0x2, 0x2, 0x14a, 0x14c, 0x7,
+ 0x6f, 0x2, 0x2, 0x14b, 0x149, 0x3, 0x2, 0x2, 0x2, 0x14b, 0x14c, 0x3,
+ 0x2, 0x2, 0x2, 0x14c, 0x14d, 0x3, 0x2, 0x2, 0x2, 0x14d, 0x14f, 0x7,
+ 0x4b, 0x2, 0x2, 0x14e, 0x150, 0x7, 0x6f, 0x2, 0x2, 0x14f, 0x14e, 0x3,
+ 0x2, 0x2, 0x2, 0x14f, 0x150, 0x3, 0x2, 0x2, 0x2, 0x150, 0x151, 0x3,
+ 0x2, 0x2, 0x2, 0x151, 0x15c, 0x5, 0x56, 0x2c, 0x2, 0x152, 0x154, 0x7,
+ 0x6f, 0x2, 0x2, 0x153, 0x152, 0x3, 0x2, 0x2, 0x2, 0x153, 0x154, 0x3,
+ 0x2, 0x2, 0x2, 0x154, 0x155, 0x3, 0x2, 0x2, 0x2, 0x155, 0x157, 0x7,
+ 0x4, 0x2, 0x2, 0x156, 0x158, 0x7, 0x6f, 0x2, 0x2, 0x157, 0x156, 0x3,
+ 0x2, 0x2, 0x2, 0x157, 0x158, 0x3, 0x2, 0x2, 0x2, 0x158, 0x159, 0x3,
+ 0x2, 0x2, 0x2, 0x159, 0x15b, 0x5, 0x56, 0x2c, 0x2, 0x15a, 0x153, 0x3,
+ 0x2, 0x2, 0x2, 0x15b, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15a, 0x3,
+ 0x2, 0x2, 0x2, 0x15c, 0x15d, 0x3, 0x2, 0x2, 0x2, 0x15d, 0x1f, 0x3, 0x2,
+ 0x2, 0x2, 0x15e, 0x15c, 0x3, 0x2, 0x2, 0x2, 0x15f, 0x160, 0x7, 0x4c,
+ 0x2, 0x2, 0x160, 0x161, 0x7, 0x6f, 0x2, 0x2, 0x161, 0x16c, 0x5, 0x22,
+ 0x12, 0x2, 0x162, 0x164, 0x7, 0x6f, 0x2, 0x2, 0x163, 0x162, 0x3, 0x2,
+ 0x2, 0x2, 0x163, 0x164, 0x3, 0x2, 0x2, 0x2, 0x164, 0x165, 0x3, 0x2,
+ 0x2, 0x2, 0x165, 0x167, 0x7, 0x4, 0x2, 0x2, 0x166, 0x168, 0x7, 0x6f,
+ 0x2, 0x2, 0x167, 0x166, 0x3, 0x2, 0x2, 0x2, 0x167, 0x168, 0x3, 0x2,
+ 0x2, 0x2, 0x168, 0x169, 0x3, 0x2, 0x2, 0x2, 0x169, 0x16b, 0x5, 0x22,
+ 0x12, 0x2, 0x16a, 0x163, 0x3, 0x2, 0x2, 0x2, 0x16b, 0x16e, 0x3, 0x2,
+ 0x2, 0x2, 0x16c, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16d, 0x3, 0x2,
+ 0x2, 0x2, 0x16d, 0x21, 0x3, 0x2, 0x2, 0x2, 0x16e, 0x16c, 0x3, 0x2, 0x2,
+ 0x2, 0x16f, 0x170, 0x5, 0x8a, 0x46, 0x2, 0x170, 0x171, 0x5, 0x4c, 0x27,
+ 0x2, 0x171, 0x174, 0x3, 0x2, 0x2, 0x2, 0x172, 0x174, 0x5, 0x92, 0x4a,
+ 0x2, 0x173, 0x16f, 0x3, 0x2, 0x2, 0x2, 0x173, 0x172, 0x3, 0x2, 0x2,
+ 0x2, 0x174, 0x23, 0x3, 0x2, 0x2, 0x2, 0x175, 0x17a, 0x7, 0x4d, 0x2,
+ 0x2, 0x176, 0x178, 0x7, 0x6f, 0x2, 0x2, 0x177, 0x176, 0x3, 0x2, 0x2,
+ 0x2, 0x177, 0x178, 0x3, 0x2, 0x2, 0x2, 0x178, 0x179, 0x3, 0x2, 0x2,
+ 0x2, 0x179, 0x17b, 0x7, 0x4e, 0x2, 0x2, 0x17a, 0x177, 0x3, 0x2, 0x2,
+ 0x2, 0x17a, 0x17b, 0x3, 0x2, 0x2, 0x2, 0x17b, 0x17c, 0x3, 0x2, 0x2,
+ 0x2, 0x17c, 0x17d, 0x7, 0x6f, 0x2, 0x2, 0x17d, 0x182, 0x5, 0x28, 0x15,
+ 0x2, 0x17e, 0x180, 0x7, 0x6f, 0x2, 0x2, 0x17f, 0x17e, 0x3, 0x2, 0x2,
+ 0x2, 0x17f, 0x180, 0x3, 0x2, 0x2, 0x2, 0x180, 0x181, 0x3, 0x2, 0x2,
+ 0x2, 0x181, 0x183, 0x5, 0x36, 0x1c, 0x2, 0x182, 0x17f, 0x3, 0x2, 0x2,
+ 0x2, 0x182, 0x183, 0x3, 0x2, 0x2, 0x2, 0x183, 0x25, 0x3, 0x2, 0x2, 0x2,
+ 0x184, 0x189, 0x7, 0x4f, 0x2, 0x2, 0x185, 0x187, 0x7, 0x6f, 0x2, 0x2,
+ 0x186, 0x185, 0x3, 0x2, 0x2, 0x2, 0x186, 0x187, 0x3, 0x2, 0x2, 0x2,
+ 0x187, 0x188, 0x3, 0x2, 0x2, 0x2, 0x188, 0x18a, 0x7, 0x4e, 0x2, 0x2,
+ 0x189, 0x186, 0x3, 0x2, 0x2, 0x2, 0x189, 0x18a, 0x3, 0x2, 0x2, 0x2,
+ 0x18a, 0x18b, 0x3, 0x2, 0x2, 0x2, 0x18b, 0x18c, 0x7, 0x6f, 0x2, 0x2,
+ 0x18c, 0x18d, 0x5, 0x28, 0x15, 0x2, 0x18d, 0x27, 0x3, 0x2, 0x2, 0x2,
+ 0x18e, 0x191, 0x5, 0x2a, 0x16, 0x2, 0x18f, 0x190, 0x7, 0x6f, 0x2, 0x2,
+ 0x190, 0x192, 0x5, 0x2e, 0x18, 0x2, 0x191, 0x18f, 0x3, 0x2, 0x2, 0x2,
+ 0x191, 0x192, 0x3, 0x2, 0x2, 0x2, 0x192, 0x195, 0x3, 0x2, 0x2, 0x2,
+ 0x193, 0x194, 0x7, 0x6f, 0x2, 0x2, 0x194, 0x196, 0x5, 0x30, 0x19, 0x2,
+ 0x195, 0x193, 0x3, 0x2, 0x2, 0x2, 0x195, 0x196, 0x3, 0x2, 0x2, 0x2,
+ 0x196, 0x199, 0x3, 0x2, 0x2, 0x2, 0x197, 0x198, 0x7, 0x6f, 0x2, 0x2,
+ 0x198, 0x19a, 0x5, 0x32, 0x1a, 0x2, 0x199, 0x197, 0x3, 0x2, 0x2, 0x2,
+ 0x199, 0x19a, 0x3, 0x2, 0x2, 0x2, 0x19a, 0x29, 0x3, 0x2, 0x2, 0x2, 0x19b,
+ 0x1a6, 0x7, 0x7, 0x2, 0x2, 0x19c, 0x19e, 0x7, 0x6f, 0x2, 0x2, 0x19d,
+ 0x19c, 0x3, 0x2, 0x2, 0x2, 0x19d, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x19e,
+ 0x19f, 0x3, 0x2, 0x2, 0x2, 0x19f, 0x1a1, 0x7, 0x4, 0x2, 0x2, 0x1a0,
+ 0x1a2, 0x7, 0x6f, 0x2, 0x2, 0x1a1, 0x1a0, 0x3, 0x2, 0x2, 0x2, 0x1a1,
+ 0x1a2, 0x3, 0x2, 0x2, 0x2, 0x1a2, 0x1a3, 0x3, 0x2, 0x2, 0x2, 0x1a3,
+ 0x1a5, 0x5, 0x2c, 0x17, 0x2, 0x1a4, 0x19d, 0x3, 0x2, 0x2, 0x2, 0x1a5,
+ 0x1a8, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x1a6,
+ 0x1a7, 0x3, 0x2, 0x2, 0x2, 0x1a7, 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1a8,
+ 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x1a9, 0x1b4, 0x5, 0x2c, 0x17, 0x2, 0x1aa,
+ 0x1ac, 0x7, 0x6f, 0x2, 0x2, 0x1ab, 0x1aa, 0x3, 0x2, 0x2, 0x2, 0x1ab,
+ 0x1ac, 0x3, 0x2, 0x2, 0x2, 0x1ac, 0x1ad, 0x3, 0x2, 0x2, 0x2, 0x1ad,
+ 0x1af, 0x7, 0x4, 0x2, 0x2, 0x1ae, 0x1b0, 0x7, 0x6f, 0x2, 0x2, 0x1af,
+ 0x1ae, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b0,
+ 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x1b1, 0x1b3, 0x5, 0x2c, 0x17, 0x2, 0x1b2,
+ 0x1ab, 0x3, 0x2, 0x2, 0x2, 0x1b3, 0x1b6, 0x3, 0x2, 0x2, 0x2, 0x1b4,
+ 0x1b2, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b5, 0x3, 0x2, 0x2, 0x2, 0x1b5,
+ 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1b6, 0x1b4, 0x3, 0x2, 0x2, 0x2, 0x1b7,
+ 0x19b, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1a9, 0x3, 0x2, 0x2, 0x2, 0x1b8,
+ 0x2b, 0x3, 0x2, 0x2, 0x2, 0x1b9, 0x1ba, 0x5, 0x56, 0x2c, 0x2, 0x1ba,
+ 0x1bb, 0x7, 0x6f, 0x2, 0x2, 0x1bb, 0x1bc, 0x7, 0x45, 0x2, 0x2, 0x1bc,
+ 0x1bd, 0x7, 0x6f, 0x2, 0x2, 0x1bd, 0x1be, 0x5, 0x8a, 0x46, 0x2, 0x1be,
+ 0x1c1, 0x3, 0x2, 0x2, 0x2, 0x1bf, 0x1c1, 0x5, 0x56, 0x2c, 0x2, 0x1c0,
+ 0x1b9, 0x3, 0x2, 0x2, 0x2, 0x1c0, 0x1bf, 0x3, 0x2, 0x2, 0x2, 0x1c1,
+ 0x2d, 0x3, 0x2, 0x2, 0x2, 0x1c2, 0x1c3, 0x7, 0x50, 0x2, 0x2, 0x1c3,
+ 0x1c4, 0x7, 0x6f, 0x2, 0x2, 0x1c4, 0x1c5, 0x7, 0x51, 0x2, 0x2, 0x1c5,
+ 0x1c6, 0x7, 0x6f, 0x2, 0x2, 0x1c6, 0x1ce, 0x5, 0x34, 0x1b, 0x2, 0x1c7,
+ 0x1c9, 0x7, 0x4, 0x2, 0x2, 0x1c8, 0x1ca, 0x7, 0x6f, 0x2, 0x2, 0x1c9,
+ 0x1c8, 0x3, 0x2, 0x2, 0x2, 0x1c9, 0x1ca, 0x3, 0x2, 0x2, 0x2, 0x1ca,
+ 0x1cb, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x1cd, 0x5, 0x34, 0x1b, 0x2, 0x1cc,
+ 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x1cd, 0x1d0, 0x3, 0x2, 0x2, 0x2, 0x1ce,
+ 0x1cc, 0x3, 0x2, 0x2, 0x2, 0x1ce, 0x1cf, 0x3, 0x2, 0x2, 0x2, 0x1cf,
+ 0x2f, 0x3, 0x2, 0x2, 0x2, 0x1d0, 0x1ce, 0x3, 0x2, 0x2, 0x2, 0x1d1, 0x1d2,
+ 0x7, 0x52, 0x2, 0x2, 0x1d2, 0x1d3, 0x7, 0x6f, 0x2, 0x2, 0x1d3, 0x1d4,
+ 0x5, 0x56, 0x2c, 0x2, 0x1d4, 0x31, 0x3, 0x2, 0x2, 0x2, 0x1d5, 0x1d6,
+ 0x7, 0x53, 0x2, 0x2, 0x1d6, 0x1d7, 0x7, 0x6f, 0x2, 0x2, 0x1d7, 0x1d8,
+ 0x5, 0x56, 0x2c, 0x2, 0x1d8, 0x33, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1de,
+ 0x5, 0x56, 0x2c, 0x2, 0x1da, 0x1dc, 0x7, 0x6f, 0x2, 0x2, 0x1db, 0x1da,
+ 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dc, 0x3, 0x2, 0x2, 0x2, 0x1dc, 0x1dd,
+ 0x3, 0x2, 0x2, 0x2, 0x1dd, 0x1df, 0x9, 0x2, 0x2, 0x2, 0x1de, 0x1db,
+ 0x3, 0x2, 0x2, 0x2, 0x1de, 0x1df, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x35, 0x3,
+ 0x2, 0x2, 0x2, 0x1e0, 0x1e1, 0x7, 0x58, 0x2, 0x2, 0x1e1, 0x1e2, 0x7,
+ 0x6f, 0x2, 0x2, 0x1e2, 0x1e3, 0x5, 0x56, 0x2c, 0x2, 0x1e3, 0x37, 0x3,
+ 0x2, 0x2, 0x2, 0x1e4, 0x1ef, 0x5, 0x3a, 0x1e, 0x2, 0x1e5, 0x1e7, 0x7,
+ 0x6f, 0x2, 0x2, 0x1e6, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e6, 0x1e7, 0x3,
+ 0x2, 0x2, 0x2, 0x1e7, 0x1e8, 0x3, 0x2, 0x2, 0x2, 0x1e8, 0x1ea, 0x7,
+ 0x4, 0x2, 0x2, 0x1e9, 0x1eb, 0x7, 0x6f, 0x2, 0x2, 0x1ea, 0x1e9, 0x3,
+ 0x2, 0x2, 0x2, 0x1ea, 0x1eb, 0x3, 0x2, 0x2, 0x2, 0x1eb, 0x1ec, 0x3,
+ 0x2, 0x2, 0x2, 0x1ec, 0x1ee, 0x5, 0x3a, 0x1e, 0x2, 0x1ed, 0x1e6, 0x3,
+ 0x2, 0x2, 0x2, 0x1ee, 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x1ef, 0x1ed, 0x3,
+ 0x2, 0x2, 0x2, 0x1ef, 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x39, 0x3, 0x2,
+ 0x2, 0x2, 0x1f1, 0x1ef, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f4, 0x5, 0x8a,
+ 0x46, 0x2, 0x1f3, 0x1f5, 0x7, 0x6f, 0x2, 0x2, 0x1f4, 0x1f3, 0x3, 0x2,
+ 0x2, 0x2, 0x1f4, 0x1f5, 0x3, 0x2, 0x2, 0x2, 0x1f5, 0x1f6, 0x3, 0x2,
+ 0x2, 0x2, 0x1f6, 0x1f8, 0x7, 0x5, 0x2, 0x2, 0x1f7, 0x1f9, 0x7, 0x6f,
+ 0x2, 0x2, 0x1f8, 0x1f7, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1f9, 0x3, 0x2,
+ 0x2, 0x2, 0x1f9, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x1fa, 0x1fb, 0x5, 0x3c,
+ 0x1f, 0x2, 0x1fb, 0x1fe, 0x3, 0x2, 0x2, 0x2, 0x1fc, 0x1fe, 0x5, 0x3c,
+ 0x1f, 0x2, 0x1fd, 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x1fd, 0x1fc, 0x3, 0x2,
+ 0x2, 0x2, 0x1fe, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x1ff, 0x200, 0x5, 0x3e,
+ 0x20, 0x2, 0x200, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x201, 0x208, 0x5, 0x40,
+ 0x21, 0x2, 0x202, 0x204, 0x7, 0x6f, 0x2, 0x2, 0x203, 0x202, 0x3, 0x2,
+ 0x2, 0x2, 0x203, 0x204, 0x3, 0x2, 0x2, 0x2, 0x204, 0x205, 0x3, 0x2,
+ 0x2, 0x2, 0x205, 0x207, 0x5, 0x42, 0x22, 0x2, 0x206, 0x203, 0x3, 0x2,
+ 0x2, 0x2, 0x207, 0x20a, 0x3, 0x2, 0x2, 0x2, 0x208, 0x206, 0x3, 0x2,
+ 0x2, 0x2, 0x208, 0x209, 0x3, 0x2, 0x2, 0x2, 0x209, 0x210, 0x3, 0x2,
+ 0x2, 0x2, 0x20a, 0x208, 0x3, 0x2, 0x2, 0x2, 0x20b, 0x20c, 0x7, 0x8,
+ 0x2, 0x2, 0x20c, 0x20d, 0x5, 0x3e, 0x20, 0x2, 0x20d, 0x20e, 0x7, 0x9,
+ 0x2, 0x2, 0x20e, 0x210, 0x3, 0x2, 0x2, 0x2, 0x20f, 0x201, 0x3, 0x2,
+ 0x2, 0x2, 0x20f, 0x20b, 0x3, 0x2, 0x2, 0x2, 0x210, 0x3f, 0x3, 0x2, 0x2,
+ 0x2, 0x211, 0x213, 0x7, 0x8, 0x2, 0x2, 0x212, 0x214, 0x7, 0x6f, 0x2,
+ 0x2, 0x213, 0x212, 0x3, 0x2, 0x2, 0x2, 0x213, 0x214, 0x3, 0x2, 0x2,
+ 0x2, 0x214, 0x219, 0x3, 0x2, 0x2, 0x2, 0x215, 0x217, 0x5, 0x8a, 0x46,
+ 0x2, 0x216, 0x218, 0x7, 0x6f, 0x2, 0x2, 0x217, 0x216, 0x3, 0x2, 0x2,
+ 0x2, 0x217, 0x218, 0x3, 0x2, 0x2, 0x2, 0x218, 0x21a, 0x3, 0x2, 0x2,
+ 0x2, 0x219, 0x215, 0x3, 0x2, 0x2, 0x2, 0x219, 0x21a, 0x3, 0x2, 0x2,
+ 0x2, 0x21a, 0x21f, 0x3, 0x2, 0x2, 0x2, 0x21b, 0x21d, 0x5, 0x4c, 0x27,
+ 0x2, 0x21c, 0x21e, 0x7, 0x6f, 0x2, 0x2, 0x21d, 0x21c, 0x3, 0x2, 0x2,
+ 0x2, 0x21d, 0x21e, 0x3, 0x2, 0x2, 0x2, 0x21e, 0x220, 0x3, 0x2, 0x2,
+ 0x2, 0x21f, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x21f, 0x220, 0x3, 0x2, 0x2,
+ 0x2, 0x220, 0x225, 0x3, 0x2, 0x2, 0x2, 0x221, 0x223, 0x5, 0x48, 0x25,
+ 0x2, 0x222, 0x224, 0x7, 0x6f, 0x2, 0x2, 0x223, 0x222, 0x3, 0x2, 0x2,
+ 0x2, 0x223, 0x224, 0x3, 0x2, 0x2, 0x2, 0x224, 0x226, 0x3, 0x2, 0x2,
+ 0x2, 0x225, 0x221, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x3, 0x2, 0x2,
+ 0x2, 0x226, 0x227, 0x3, 0x2, 0x2, 0x2, 0x227, 0x228, 0x7, 0x9, 0x2,
+ 0x2, 0x228, 0x41, 0x3, 0x2, 0x2, 0x2, 0x229, 0x22b, 0x5, 0x44, 0x23,
+ 0x2, 0x22a, 0x22c, 0x7, 0x6f, 0x2, 0x2, 0x22b, 0x22a, 0x3, 0x2, 0x2,
+ 0x2, 0x22b, 0x22c, 0x3, 0x2, 0x2, 0x2, 0x22c, 0x22d, 0x3, 0x2, 0x2,
+ 0x2, 0x22d, 0x22e, 0x5, 0x40, 0x21, 0x2, 0x22e, 0x43, 0x3, 0x2, 0x2,
+ 0x2, 0x22f, 0x231, 0x5, 0x9c, 0x4f, 0x2, 0x230, 0x232, 0x7, 0x6f, 0x2,
+ 0x2, 0x231, 0x230, 0x3, 0x2, 0x2, 0x2, 0x231, 0x232, 0x3, 0x2, 0x2,
+ 0x2, 0x232, 0x233, 0x3, 0x2, 0x2, 0x2, 0x233, 0x235, 0x5, 0xa0, 0x51,
+ 0x2, 0x234, 0x236, 0x7, 0x6f, 0x2, 0x2, 0x235, 0x234, 0x3, 0x2, 0x2,
+ 0x2, 0x235, 0x236, 0x3, 0x2, 0x2, 0x2, 0x236, 0x238, 0x3, 0x2, 0x2,
+ 0x2, 0x237, 0x239, 0x5, 0x46, 0x24, 0x2, 0x238, 0x237, 0x3, 0x2, 0x2,
+ 0x2, 0x238, 0x239, 0x3, 0x2, 0x2, 0x2, 0x239, 0x23b, 0x3, 0x2, 0x2,
+ 0x2, 0x23a, 0x23c, 0x7, 0x6f, 0x2, 0x2, 0x23b, 0x23a, 0x3, 0x2, 0x2,
+ 0x2, 0x23b, 0x23c, 0x3, 0x2, 0x2, 0x2, 0x23c, 0x23d, 0x3, 0x2, 0x2,
+ 0x2, 0x23d, 0x23f, 0x5, 0xa0, 0x51, 0x2, 0x23e, 0x240, 0x7, 0x6f, 0x2,
+ 0x2, 0x23f, 0x23e, 0x3, 0x2, 0x2, 0x2, 0x23f, 0x240, 0x3, 0x2, 0x2,
+ 0x2, 0x240, 0x241, 0x3, 0x2, 0x2, 0x2, 0x241, 0x242, 0x5, 0x9e, 0x50,
+ 0x2, 0x242, 0x270, 0x3, 0x2, 0x2, 0x2, 0x243, 0x245, 0x5, 0x9c, 0x4f,
+ 0x2, 0x244, 0x246, 0x7, 0x6f, 0x2, 0x2, 0x245, 0x244, 0x3, 0x2, 0x2,
+ 0x2, 0x245, 0x246, 0x3, 0x2, 0x2, 0x2, 0x246, 0x247, 0x3, 0x2, 0x2,
+ 0x2, 0x247, 0x249, 0x5, 0xa0, 0x51, 0x2, 0x248, 0x24a, 0x7, 0x6f, 0x2,
+ 0x2, 0x249, 0x248, 0x3, 0x2, 0x2, 0x2, 0x249, 0x24a, 0x3, 0x2, 0x2,
+ 0x2, 0x24a, 0x24c, 0x3, 0x2, 0x2, 0x2, 0x24b, 0x24d, 0x5, 0x46, 0x24,
+ 0x2, 0x24c, 0x24b, 0x3, 0x2, 0x2, 0x2, 0x24c, 0x24d, 0x3, 0x2, 0x2,
+ 0x2, 0x24d, 0x24f, 0x3, 0x2, 0x2, 0x2, 0x24e, 0x250, 0x7, 0x6f, 0x2,
+ 0x2, 0x24f, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x24f, 0x250, 0x3, 0x2, 0x2,
+ 0x2, 0x250, 0x251, 0x3, 0x2, 0x2, 0x2, 0x251, 0x252, 0x5, 0xa0, 0x51,
+ 0x2, 0x252, 0x270, 0x3, 0x2, 0x2, 0x2, 0x253, 0x255, 0x5, 0xa0, 0x51,
+ 0x2, 0x254, 0x256, 0x7, 0x6f, 0x2, 0x2, 0x255, 0x254, 0x3, 0x2, 0x2,
+ 0x2, 0x255, 0x256, 0x3, 0x2, 0x2, 0x2, 0x256, 0x258, 0x3, 0x2, 0x2,
+ 0x2, 0x257, 0x259, 0x5, 0x46, 0x24, 0x2, 0x258, 0x257, 0x3, 0x2, 0x2,
+ 0x2, 0x258, 0x259, 0x3, 0x2, 0x2, 0x2, 0x259, 0x25b, 0x3, 0x2, 0x2,
+ 0x2, 0x25a, 0x25c, 0x7, 0x6f, 0x2, 0x2, 0x25b, 0x25a, 0x3, 0x2, 0x2,
+ 0x2, 0x25b, 0x25c, 0x3, 0x2, 0x2, 0x2, 0x25c, 0x25d, 0x3, 0x2, 0x2,
+ 0x2, 0x25d, 0x25f, 0x5, 0xa0, 0x51, 0x2, 0x25e, 0x260, 0x7, 0x6f, 0x2,
+ 0x2, 0x25f, 0x25e, 0x3, 0x2, 0x2, 0x2, 0x25f, 0x260, 0x3, 0x2, 0x2,
+ 0x2, 0x260, 0x261, 0x3, 0x2, 0x2, 0x2, 0x261, 0x262, 0x5, 0x9e, 0x50,
+ 0x2, 0x262, 0x270, 0x3, 0x2, 0x2, 0x2, 0x263, 0x265, 0x5, 0xa0, 0x51,
+ 0x2, 0x264, 0x266, 0x7, 0x6f, 0x2, 0x2, 0x265, 0x264, 0x3, 0x2, 0x2,
+ 0x2, 0x265, 0x266, 0x3, 0x2, 0x2, 0x2, 0x266, 0x268, 0x3, 0x2, 0x2,
+ 0x2, 0x267, 0x269, 0x5, 0x46, 0x24, 0x2, 0x268, 0x267, 0x3, 0x2, 0x2,
+ 0x2, 0x268, 0x269, 0x3, 0x2, 0x2, 0x2, 0x269, 0x26b, 0x3, 0x2, 0x2,
+ 0x2, 0x26a, 0x26c, 0x7, 0x6f, 0x2, 0x2, 0x26b, 0x26a, 0x3, 0x2, 0x2,
+ 0x2, 0x26b, 0x26c, 0x3, 0x2, 0x2, 0x2, 0x26c, 0x26d, 0x3, 0x2, 0x2,
+ 0x2, 0x26d, 0x26e, 0x5, 0xa0, 0x51, 0x2, 0x26e, 0x270, 0x3, 0x2, 0x2,
+ 0x2, 0x26f, 0x22f, 0x3, 0x2, 0x2, 0x2, 0x26f, 0x243, 0x3, 0x2, 0x2,
+ 0x2, 0x26f, 0x253, 0x3, 0x2, 0x2, 0x2, 0x26f, 0x263, 0x3, 0x2, 0x2,
+ 0x2, 0x270, 0x45, 0x3, 0x2, 0x2, 0x2, 0x271, 0x273, 0x7, 0xa, 0x2, 0x2,
+ 0x272, 0x274, 0x7, 0x6f, 0x2, 0x2, 0x273, 0x272, 0x3, 0x2, 0x2, 0x2,
+ 0x273, 0x274, 0x3, 0x2, 0x2, 0x2, 0x274, 0x279, 0x3, 0x2, 0x2, 0x2,
+ 0x275, 0x277, 0x5, 0x8a, 0x46, 0x2, 0x276, 0x278, 0x7, 0x6f, 0x2, 0x2,
+ 0x277, 0x276, 0x3, 0x2, 0x2, 0x2, 0x277, 0x278, 0x3, 0x2, 0x2, 0x2,
+ 0x278, 0x27a, 0x3, 0x2, 0x2, 0x2, 0x279, 0x275, 0x3, 0x2, 0x2, 0x2,
+ 0x279, 0x27a, 0x3, 0x2, 0x2, 0x2, 0x27a, 0x27f, 0x3, 0x2, 0x2, 0x2,
+ 0x27b, 0x27d, 0x5, 0x4a, 0x26, 0x2, 0x27c, 0x27e, 0x7, 0x6f, 0x2, 0x2,
+ 0x27d, 0x27c, 0x3, 0x2, 0x2, 0x2, 0x27d, 0x27e, 0x3, 0x2, 0x2, 0x2,
+ 0x27e, 0x280, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x27b, 0x3, 0x2, 0x2, 0x2,
+ 0x27f, 0x280, 0x3, 0x2, 0x2, 0x2, 0x280, 0x282, 0x3, 0x2, 0x2, 0x2,
+ 0x281, 0x283, 0x5, 0x50, 0x29, 0x2, 0x282, 0x281, 0x3, 0x2, 0x2, 0x2,
+ 0x282, 0x283, 0x3, 0x2, 0x2, 0x2, 0x283, 0x288, 0x3, 0x2, 0x2, 0x2,
+ 0x284, 0x286, 0x5, 0x48, 0x25, 0x2, 0x285, 0x287, 0x7, 0x6f, 0x2, 0x2,
+ 0x286, 0x285, 0x3, 0x2, 0x2, 0x2, 0x286, 0x287, 0x3, 0x2, 0x2, 0x2,
+ 0x287, 0x289, 0x3, 0x2, 0x2, 0x2, 0x288, 0x284, 0x3, 0x2, 0x2, 0x2,
+ 0x288, 0x289, 0x3, 0x2, 0x2, 0x2, 0x289, 0x28a, 0x3, 0x2, 0x2, 0x2,
+ 0x28a, 0x28b, 0x7, 0xb, 0x2, 0x2, 0x28b, 0x47, 0x3, 0x2, 0x2, 0x2, 0x28c,
+ 0x28f, 0x5, 0x8e, 0x48, 0x2, 0x28d, 0x28f, 0x5, 0x90, 0x49, 0x2, 0x28e,
+ 0x28c, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x28d, 0x3, 0x2, 0x2, 0x2, 0x28f,
+ 0x49, 0x3, 0x2, 0x2, 0x2, 0x290, 0x292, 0x7, 0xc, 0x2, 0x2, 0x291, 0x293,
+ 0x7, 0x6f, 0x2, 0x2, 0x292, 0x291, 0x3, 0x2, 0x2, 0x2, 0x292, 0x293,
+ 0x3, 0x2, 0x2, 0x2, 0x293, 0x294, 0x3, 0x2, 0x2, 0x2, 0x294, 0x2a2,
+ 0x5, 0x54, 0x2b, 0x2, 0x295, 0x297, 0x7, 0x6f, 0x2, 0x2, 0x296, 0x295,
+ 0x3, 0x2, 0x2, 0x2, 0x296, 0x297, 0x3, 0x2, 0x2, 0x2, 0x297, 0x298,
+ 0x3, 0x2, 0x2, 0x2, 0x298, 0x29a, 0x7, 0xd, 0x2, 0x2, 0x299, 0x29b,
+ 0x7, 0xc, 0x2, 0x2, 0x29a, 0x299, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x29b,
+ 0x3, 0x2, 0x2, 0x2, 0x29b, 0x29d, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x29e,
+ 0x7, 0x6f, 0x2, 0x2, 0x29d, 0x29c, 0x3, 0x2, 0x2, 0x2, 0x29d, 0x29e,
+ 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29f, 0x3, 0x2, 0x2, 0x2, 0x29f, 0x2a1,
+ 0x5, 0x54, 0x2b, 0x2, 0x2a0, 0x296, 0x3, 0x2, 0x2, 0x2, 0x2a1, 0x2a4,
+ 0x3, 0x2, 0x2, 0x2, 0x2a2, 0x2a0, 0x3, 0x2, 0x2, 0x2, 0x2a2, 0x2a3,
+ 0x3, 0x2, 0x2, 0x2, 0x2a3, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x2a4, 0x2a2, 0x3,
+ 0x2, 0x2, 0x2, 0x2a5, 0x2ac, 0x5, 0x4e, 0x28, 0x2, 0x2a6, 0x2a8, 0x7,
+ 0x6f, 0x2, 0x2, 0x2a7, 0x2a6, 0x3, 0x2, 0x2, 0x2, 0x2a7, 0x2a8, 0x3,
+ 0x2, 0x2, 0x2, 0x2a8, 0x2a9, 0x3, 0x2, 0x2, 0x2, 0x2a9, 0x2ab, 0x5,
+ 0x4e, 0x28, 0x2, 0x2aa, 0x2a7, 0x3, 0x2, 0x2, 0x2, 0x2ab, 0x2ae, 0x3,
+ 0x2, 0x2, 0x2, 0x2ac, 0x2aa, 0x3, 0x2, 0x2, 0x2, 0x2ac, 0x2ad, 0x3,
+ 0x2, 0x2, 0x2, 0x2ad, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2ae, 0x2ac, 0x3, 0x2,
+ 0x2, 0x2, 0x2af, 0x2b1, 0x7, 0xc, 0x2, 0x2, 0x2b0, 0x2b2, 0x7, 0x6f,
+ 0x2, 0x2, 0x2b1, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x2b1, 0x2b2, 0x3, 0x2,
+ 0x2, 0x2, 0x2b2, 0x2b3, 0x3, 0x2, 0x2, 0x2, 0x2b3, 0x2b4, 0x5, 0x52,
+ 0x2a, 0x2, 0x2b4, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x2b5, 0x2b7, 0x7, 0x7,
+ 0x2, 0x2, 0x2b6, 0x2b8, 0x7, 0x6f, 0x2, 0x2, 0x2b7, 0x2b6, 0x3, 0x2,
+ 0x2, 0x2, 0x2b7, 0x2b8, 0x3, 0x2, 0x2, 0x2, 0x2b8, 0x2bd, 0x3, 0x2,
+ 0x2, 0x2, 0x2b9, 0x2bb, 0x5, 0x96, 0x4c, 0x2, 0x2ba, 0x2bc, 0x7, 0x6f,
+ 0x2, 0x2, 0x2bb, 0x2ba, 0x3, 0x2, 0x2, 0x2, 0x2bb, 0x2bc, 0x3, 0x2,
+ 0x2, 0x2, 0x2bc, 0x2be, 0x3, 0x2, 0x2, 0x2, 0x2bd, 0x2b9, 0x3, 0x2,
+ 0x2, 0x2, 0x2bd, 0x2be, 0x3, 0x2, 0x2, 0x2, 0x2be, 0x2c9, 0x3, 0x2,
+ 0x2, 0x2, 0x2bf, 0x2c1, 0x7, 0xe, 0x2, 0x2, 0x2c0, 0x2c2, 0x7, 0x6f,
+ 0x2, 0x2, 0x2c1, 0x2c0, 0x3, 0x2, 0x2, 0x2, 0x2c1, 0x2c2, 0x3, 0x2,
+ 0x2, 0x2, 0x2c2, 0x2c7, 0x3, 0x2, 0x2, 0x2, 0x2c3, 0x2c5, 0x5, 0x96,
+ 0x4c, 0x2, 0x2c4, 0x2c6, 0x7, 0x6f, 0x2, 0x2, 0x2c5, 0x2c4, 0x3, 0x2,
+ 0x2, 0x2, 0x2c5, 0x2c6, 0x3, 0x2, 0x2, 0x2, 0x2c6, 0x2c8, 0x3, 0x2,
+ 0x2, 0x2, 0x2c7, 0x2c3, 0x3, 0x2, 0x2, 0x2, 0x2c7, 0x2c8, 0x3, 0x2,
+ 0x2, 0x2, 0x2c8, 0x2ca, 0x3, 0x2, 0x2, 0x2, 0x2c9, 0x2bf, 0x3, 0x2,
+ 0x2, 0x2, 0x2c9, 0x2ca, 0x3, 0x2, 0x2, 0x2, 0x2ca, 0x51, 0x3, 0x2, 0x2,
+ 0x2, 0x2cb, 0x2cc, 0x5, 0x9a, 0x4e, 0x2, 0x2cc, 0x53, 0x3, 0x2, 0x2,
+ 0x2, 0x2cd, 0x2ce, 0x5, 0x9a, 0x4e, 0x2, 0x2ce, 0x55, 0x3, 0x2, 0x2,
+ 0x2, 0x2cf, 0x2d0, 0x5, 0x58, 0x2d, 0x2, 0x2d0, 0x57, 0x3, 0x2, 0x2,
+ 0x2, 0x2d1, 0x2d8, 0x5, 0x5a, 0x2e, 0x2, 0x2d2, 0x2d3, 0x7, 0x6f, 0x2,
+ 0x2, 0x2d3, 0x2d4, 0x7, 0x59, 0x2, 0x2, 0x2d4, 0x2d5, 0x7, 0x6f, 0x2,
+ 0x2, 0x2d5, 0x2d7, 0x5, 0x5a, 0x2e, 0x2, 0x2d6, 0x2d2, 0x3, 0x2, 0x2,
+ 0x2, 0x2d7, 0x2da, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2d6, 0x3, 0x2, 0x2,
+ 0x2, 0x2d8, 0x2d9, 0x3, 0x2, 0x2, 0x2, 0x2d9, 0x59, 0x3, 0x2, 0x2, 0x2,
+ 0x2da, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0x2db, 0x2e2, 0x5, 0x5c, 0x2f, 0x2,
+ 0x2dc, 0x2dd, 0x7, 0x6f, 0x2, 0x2, 0x2dd, 0x2de, 0x7, 0x5a, 0x2, 0x2,
+ 0x2de, 0x2df, 0x7, 0x6f, 0x2, 0x2, 0x2df, 0x2e1, 0x5, 0x5c, 0x2f, 0x2,
+ 0x2e0, 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x2e1, 0x2e4, 0x3, 0x2, 0x2, 0x2,
+ 0x2e2, 0x2e0, 0x3, 0x2, 0x2, 0x2, 0x2e2, 0x2e3, 0x3, 0x2, 0x2, 0x2,
+ 0x2e3, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2e5,
+ 0x2ec, 0x5, 0x5e, 0x30, 0x2, 0x2e6, 0x2e7, 0x7, 0x6f, 0x2, 0x2, 0x2e7,
+ 0x2e8, 0x7, 0x5b, 0x2, 0x2, 0x2e8, 0x2e9, 0x7, 0x6f, 0x2, 0x2, 0x2e9,
+ 0x2eb, 0x5, 0x5e, 0x30, 0x2, 0x2ea, 0x2e6, 0x3, 0x2, 0x2, 0x2, 0x2eb,
+ 0x2ee, 0x3, 0x2, 0x2, 0x2, 0x2ec, 0x2ea, 0x3, 0x2, 0x2, 0x2, 0x2ec,
+ 0x2ed, 0x3, 0x2, 0x2, 0x2, 0x2ed, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x2ee, 0x2ec,
+ 0x3, 0x2, 0x2, 0x2, 0x2ef, 0x2f1, 0x7, 0x5c, 0x2, 0x2, 0x2f0, 0x2f2,
+ 0x7, 0x6f, 0x2, 0x2, 0x2f1, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x2f2,
+ 0x3, 0x2, 0x2, 0x2, 0x2f2, 0x2f4, 0x3, 0x2, 0x2, 0x2, 0x2f3, 0x2ef,
+ 0x3, 0x2, 0x2, 0x2, 0x2f4, 0x2f7, 0x3, 0x2, 0x2, 0x2, 0x2f5, 0x2f3,
+ 0x3, 0x2, 0x2, 0x2, 0x2f5, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x2f6, 0x2f8,
+ 0x3, 0x2, 0x2, 0x2, 0x2f7, 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x2f8, 0x2f9,
+ 0x5, 0x60, 0x31, 0x2, 0x2f9, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x2fa, 0x301,
+ 0x5, 0x62, 0x32, 0x2, 0x2fb, 0x2fd, 0x7, 0x6f, 0x2, 0x2, 0x2fc, 0x2fb,
+ 0x3, 0x2, 0x2, 0x2, 0x2fc, 0x2fd, 0x3, 0x2, 0x2, 0x2, 0x2fd, 0x2fe,
+ 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x300, 0x5, 0x76, 0x3c, 0x2, 0x2ff, 0x2fc,
+ 0x3, 0x2, 0x2, 0x2, 0x300, 0x303, 0x3, 0x2, 0x2, 0x2, 0x301, 0x2ff,
+ 0x3, 0x2, 0x2, 0x2, 0x301, 0x302, 0x3, 0x2, 0x2, 0x2, 0x302, 0x61, 0x3,
+ 0x2, 0x2, 0x2, 0x303, 0x301, 0x3, 0x2, 0x2, 0x2, 0x304, 0x317, 0x5,
+ 0x64, 0x33, 0x2, 0x305, 0x307, 0x7, 0x6f, 0x2, 0x2, 0x306, 0x305, 0x3,
+ 0x2, 0x2, 0x2, 0x306, 0x307, 0x3, 0x2, 0x2, 0x2, 0x307, 0x308, 0x3,
+ 0x2, 0x2, 0x2, 0x308, 0x30a, 0x7, 0xf, 0x2, 0x2, 0x309, 0x30b, 0x7,
+ 0x6f, 0x2, 0x2, 0x30a, 0x309, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x30b, 0x3,
+ 0x2, 0x2, 0x2, 0x30b, 0x30c, 0x3, 0x2, 0x2, 0x2, 0x30c, 0x316, 0x5,
+ 0x64, 0x33, 0x2, 0x30d, 0x30f, 0x7, 0x6f, 0x2, 0x2, 0x30e, 0x30d, 0x3,
+ 0x2, 0x2, 0x2, 0x30e, 0x30f, 0x3, 0x2, 0x2, 0x2, 0x30f, 0x310, 0x3,
+ 0x2, 0x2, 0x2, 0x310, 0x312, 0x7, 0x10, 0x2, 0x2, 0x311, 0x313, 0x7,
+ 0x6f, 0x2, 0x2, 0x312, 0x311, 0x3, 0x2, 0x2, 0x2, 0x312, 0x313, 0x3,
+ 0x2, 0x2, 0x2, 0x313, 0x314, 0x3, 0x2, 0x2, 0x2, 0x314, 0x316, 0x5,
+ 0x64, 0x33, 0x2, 0x315, 0x306, 0x3, 0x2, 0x2, 0x2, 0x315, 0x30e, 0x3,
+ 0x2, 0x2, 0x2, 0x316, 0x319, 0x3, 0x2, 0x2, 0x2, 0x317, 0x315, 0x3,
+ 0x2, 0x2, 0x2, 0x317, 0x318, 0x3, 0x2, 0x2, 0x2, 0x318, 0x63, 0x3, 0x2,
+ 0x2, 0x2, 0x319, 0x317, 0x3, 0x2, 0x2, 0x2, 0x31a, 0x335, 0x5, 0x66,
+ 0x34, 0x2, 0x31b, 0x31d, 0x7, 0x6f, 0x2, 0x2, 0x31c, 0x31b, 0x3, 0x2,
+ 0x2, 0x2, 0x31c, 0x31d, 0x3, 0x2, 0x2, 0x2, 0x31d, 0x31e, 0x3, 0x2,
+ 0x2, 0x2, 0x31e, 0x320, 0x7, 0x7, 0x2, 0x2, 0x31f, 0x321, 0x7, 0x6f,
+ 0x2, 0x2, 0x320, 0x31f, 0x3, 0x2, 0x2, 0x2, 0x320, 0x321, 0x3, 0x2,
+ 0x2, 0x2, 0x321, 0x322, 0x3, 0x2, 0x2, 0x2, 0x322, 0x334, 0x5, 0x66,
+ 0x34, 0x2, 0x323, 0x325, 0x7, 0x6f, 0x2, 0x2, 0x324, 0x323, 0x3, 0x2,
+ 0x2, 0x2, 0x324, 0x325, 0x3, 0x2, 0x2, 0x2, 0x325, 0x326, 0x3, 0x2,
+ 0x2, 0x2, 0x326, 0x328, 0x7, 0x11, 0x2, 0x2, 0x327, 0x329, 0x7, 0x6f,
+ 0x2, 0x2, 0x328, 0x327, 0x3, 0x2, 0x2, 0x2, 0x328, 0x329, 0x3, 0x2,
+ 0x2, 0x2, 0x329, 0x32a, 0x3, 0x2, 0x2, 0x2, 0x32a, 0x334, 0x5, 0x66,
+ 0x34, 0x2, 0x32b, 0x32d, 0x7, 0x6f, 0x2, 0x2, 0x32c, 0x32b, 0x3, 0x2,
+ 0x2, 0x2, 0x32c, 0x32d, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x32e, 0x3, 0x2,
+ 0x2, 0x2, 0x32e, 0x330, 0x7, 0x12, 0x2, 0x2, 0x32f, 0x331, 0x7, 0x6f,
+ 0x2, 0x2, 0x330, 0x32f, 0x3, 0x2, 0x2, 0x2, 0x330, 0x331, 0x3, 0x2,
+ 0x2, 0x2, 0x331, 0x332, 0x3, 0x2, 0x2, 0x2, 0x332, 0x334, 0x5, 0x66,
+ 0x34, 0x2, 0x333, 0x31c, 0x3, 0x2, 0x2, 0x2, 0x333, 0x324, 0x3, 0x2,
+ 0x2, 0x2, 0x333, 0x32c, 0x3, 0x2, 0x2, 0x2, 0x334, 0x337, 0x3, 0x2,
+ 0x2, 0x2, 0x335, 0x333, 0x3, 0x2, 0x2, 0x2, 0x335, 0x336, 0x3, 0x2,
+ 0x2, 0x2, 0x336, 0x65, 0x3, 0x2, 0x2, 0x2, 0x337, 0x335, 0x3, 0x2, 0x2,
+ 0x2, 0x338, 0x343, 0x5, 0x68, 0x35, 0x2, 0x339, 0x33b, 0x7, 0x6f, 0x2,
+ 0x2, 0x33a, 0x339, 0x3, 0x2, 0x2, 0x2, 0x33a, 0x33b, 0x3, 0x2, 0x2,
+ 0x2, 0x33b, 0x33c, 0x3, 0x2, 0x2, 0x2, 0x33c, 0x33e, 0x7, 0x13, 0x2,
+ 0x2, 0x33d, 0x33f, 0x7, 0x6f, 0x2, 0x2, 0x33e, 0x33d, 0x3, 0x2, 0x2,
+ 0x2, 0x33e, 0x33f, 0x3, 0x2, 0x2, 0x2, 0x33f, 0x340, 0x3, 0x2, 0x2,
+ 0x2, 0x340, 0x342, 0x5, 0x68, 0x35, 0x2, 0x341, 0x33a, 0x3, 0x2, 0x2,
+ 0x2, 0x342, 0x345, 0x3, 0x2, 0x2, 0x2, 0x343, 0x341, 0x3, 0x2, 0x2,
+ 0x2, 0x343, 0x344, 0x3, 0x2, 0x2, 0x2, 0x344, 0x67, 0x3, 0x2, 0x2, 0x2,
+ 0x345, 0x343, 0x3, 0x2, 0x2, 0x2, 0x346, 0x348, 0x9, 0x3, 0x2, 0x2,
+ 0x347, 0x349, 0x7, 0x6f, 0x2, 0x2, 0x348, 0x347, 0x3, 0x2, 0x2, 0x2,
+ 0x348, 0x349, 0x3, 0x2, 0x2, 0x2, 0x349, 0x34b, 0x3, 0x2, 0x2, 0x2,
+ 0x34a, 0x346, 0x3, 0x2, 0x2, 0x2, 0x34b, 0x34e, 0x3, 0x2, 0x2, 0x2,
+ 0x34c, 0x34a, 0x3, 0x2, 0x2, 0x2, 0x34c, 0x34d, 0x3, 0x2, 0x2, 0x2,
+ 0x34d, 0x34f, 0x3, 0x2, 0x2, 0x2, 0x34e, 0x34c, 0x3, 0x2, 0x2, 0x2,
+ 0x34f, 0x350, 0x5, 0x6a, 0x36, 0x2, 0x350, 0x69, 0x3, 0x2, 0x2, 0x2,
+ 0x351, 0x387, 0x5, 0x6c, 0x37, 0x2, 0x352, 0x354, 0x7, 0x6f, 0x2, 0x2,
+ 0x353, 0x352, 0x3, 0x2, 0x2, 0x2, 0x353, 0x354, 0x3, 0x2, 0x2, 0x2,
+ 0x354, 0x355, 0x3, 0x2, 0x2, 0x2, 0x355, 0x356, 0x7, 0xa, 0x2, 0x2,
+ 0x356, 0x357, 0x5, 0x56, 0x2c, 0x2, 0x357, 0x358, 0x7, 0xb, 0x2, 0x2,
+ 0x358, 0x386, 0x3, 0x2, 0x2, 0x2, 0x359, 0x35b, 0x7, 0x6f, 0x2, 0x2,
+ 0x35a, 0x359, 0x3, 0x2, 0x2, 0x2, 0x35a, 0x35b, 0x3, 0x2, 0x2, 0x2,
+ 0x35b, 0x35c, 0x3, 0x2, 0x2, 0x2, 0x35c, 0x35e, 0x7, 0xa, 0x2, 0x2,
+ 0x35d, 0x35f, 0x5, 0x56, 0x2c, 0x2, 0x35e, 0x35d, 0x3, 0x2, 0x2, 0x2,
+ 0x35e, 0x35f, 0x3, 0x2, 0x2, 0x2, 0x35f, 0x360, 0x3, 0x2, 0x2, 0x2,
+ 0x360, 0x362, 0x7, 0xe, 0x2, 0x2, 0x361, 0x363, 0x5, 0x56, 0x2c, 0x2,
+ 0x362, 0x361, 0x3, 0x2, 0x2, 0x2, 0x362, 0x363, 0x3, 0x2, 0x2, 0x2,
+ 0x363, 0x364, 0x3, 0x2, 0x2, 0x2, 0x364, 0x386, 0x7, 0xb, 0x2, 0x2,
+ 0x365, 0x367, 0x7, 0x6f, 0x2, 0x2, 0x366, 0x365, 0x3, 0x2, 0x2, 0x2,
+ 0x366, 0x367, 0x3, 0x2, 0x2, 0x2, 0x367, 0x368, 0x3, 0x2, 0x2, 0x2,
+ 0x368, 0x376, 0x7, 0x14, 0x2, 0x2, 0x369, 0x36a, 0x7, 0x6f, 0x2, 0x2,
+ 0x36a, 0x376, 0x7, 0x5d, 0x2, 0x2, 0x36b, 0x36c, 0x7, 0x6f, 0x2, 0x2,
+ 0x36c, 0x36d, 0x7, 0x5e, 0x2, 0x2, 0x36d, 0x36e, 0x7, 0x6f, 0x2, 0x2,
+ 0x36e, 0x376, 0x7, 0x4d, 0x2, 0x2, 0x36f, 0x370, 0x7, 0x6f, 0x2, 0x2,
+ 0x370, 0x371, 0x7, 0x5f, 0x2, 0x2, 0x371, 0x372, 0x7, 0x6f, 0x2, 0x2,
+ 0x372, 0x376, 0x7, 0x4d, 0x2, 0x2, 0x373, 0x374, 0x7, 0x6f, 0x2, 0x2,
+ 0x374, 0x376, 0x7, 0x60, 0x2, 0x2, 0x375, 0x366, 0x3, 0x2, 0x2, 0x2,
+ 0x375, 0x369, 0x3, 0x2, 0x2, 0x2, 0x375, 0x36b, 0x3, 0x2, 0x2, 0x2,
+ 0x375, 0x36f, 0x3, 0x2, 0x2, 0x2, 0x375, 0x373, 0x3, 0x2, 0x2, 0x2,
+ 0x376, 0x378, 0x3, 0x2, 0x2, 0x2, 0x377, 0x379, 0x7, 0x6f, 0x2, 0x2,
+ 0x378, 0x377, 0x3, 0x2, 0x2, 0x2, 0x378, 0x379, 0x3, 0x2, 0x2, 0x2,
+ 0x379, 0x37a, 0x3, 0x2, 0x2, 0x2, 0x37a, 0x386, 0x5, 0x6c, 0x37, 0x2,
+ 0x37b, 0x37c, 0x7, 0x6f, 0x2, 0x2, 0x37c, 0x37d, 0x7, 0x61, 0x2, 0x2,
+ 0x37d, 0x37e, 0x7, 0x6f, 0x2, 0x2, 0x37e, 0x386, 0x7, 0x62, 0x2, 0x2,
+ 0x37f, 0x380, 0x7, 0x6f, 0x2, 0x2, 0x380, 0x381, 0x7, 0x61, 0x2, 0x2,
+ 0x381, 0x382, 0x7, 0x6f, 0x2, 0x2, 0x382, 0x383, 0x7, 0x5c, 0x2, 0x2,
+ 0x383, 0x384, 0x7, 0x6f, 0x2, 0x2, 0x384, 0x386, 0x7, 0x62, 0x2, 0x2,
+ 0x385, 0x353, 0x3, 0x2, 0x2, 0x2, 0x385, 0x35a, 0x3, 0x2, 0x2, 0x2,
+ 0x385, 0x375, 0x3, 0x2, 0x2, 0x2, 0x385, 0x37b, 0x3, 0x2, 0x2, 0x2,
+ 0x385, 0x37f, 0x3, 0x2, 0x2, 0x2, 0x386, 0x389, 0x3, 0x2, 0x2, 0x2,
+ 0x387, 0x385, 0x3, 0x2, 0x2, 0x2, 0x387, 0x388, 0x3, 0x2, 0x2, 0x2,
+ 0x388, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x389, 0x387, 0x3, 0x2, 0x2, 0x2, 0x38a,
+ 0x394, 0x5, 0x6e, 0x38, 0x2, 0x38b, 0x38d, 0x7, 0x6f, 0x2, 0x2, 0x38c,
+ 0x38b, 0x3, 0x2, 0x2, 0x2, 0x38c, 0x38d, 0x3, 0x2, 0x2, 0x2, 0x38d,
+ 0x390, 0x3, 0x2, 0x2, 0x2, 0x38e, 0x391, 0x5, 0x88, 0x45, 0x2, 0x38f,
+ 0x391, 0x5, 0x4c, 0x27, 0x2, 0x390, 0x38e, 0x3, 0x2, 0x2, 0x2, 0x390,
+ 0x38f, 0x3, 0x2, 0x2, 0x2, 0x391, 0x393, 0x3, 0x2, 0x2, 0x2, 0x392,
+ 0x38c, 0x3, 0x2, 0x2, 0x2, 0x393, 0x396, 0x3, 0x2, 0x2, 0x2, 0x394,
+ 0x392, 0x3, 0x2, 0x2, 0x2, 0x394, 0x395, 0x3, 0x2, 0x2, 0x2, 0x395,
+ 0x6d, 0x3, 0x2, 0x2, 0x2, 0x396, 0x394, 0x3, 0x2, 0x2, 0x2, 0x397, 0x408,
+ 0x5, 0x70, 0x39, 0x2, 0x398, 0x408, 0x5, 0x90, 0x49, 0x2, 0x399, 0x39b,
+ 0x7, 0x63, 0x2, 0x2, 0x39a, 0x39c, 0x7, 0x6f, 0x2, 0x2, 0x39b, 0x39a,
+ 0x3, 0x2, 0x2, 0x2, 0x39b, 0x39c, 0x3, 0x2, 0x2, 0x2, 0x39c, 0x39d,
+ 0x3, 0x2, 0x2, 0x2, 0x39d, 0x39f, 0x7, 0x8, 0x2, 0x2, 0x39e, 0x3a0,
+ 0x7, 0x6f, 0x2, 0x2, 0x39f, 0x39e, 0x3, 0x2, 0x2, 0x2, 0x39f, 0x3a0,
+ 0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a1, 0x3, 0x2, 0x2, 0x2, 0x3a1, 0x3a3,
+ 0x7, 0x7, 0x2, 0x2, 0x3a2, 0x3a4, 0x7, 0x6f, 0x2, 0x2, 0x3a3, 0x3a2,
+ 0x3, 0x2, 0x2, 0x2, 0x3a3, 0x3a4, 0x3, 0x2, 0x2, 0x2, 0x3a4, 0x3a5,
+ 0x3, 0x2, 0x2, 0x2, 0x3a5, 0x408, 0x7, 0x9, 0x2, 0x2, 0x3a6, 0x408,
+ 0x5, 0x84, 0x43, 0x2, 0x3a7, 0x408, 0x5, 0x86, 0x44, 0x2, 0x3a8, 0x3aa,
+ 0x7, 0x64, 0x2, 0x2, 0x3a9, 0x3ab, 0x7, 0x6f, 0x2, 0x2, 0x3aa, 0x3a9,
+ 0x3, 0x2, 0x2, 0x2, 0x3aa, 0x3ab, 0x3, 0x2, 0x2, 0x2, 0x3ab, 0x3ac,
+ 0x3, 0x2, 0x2, 0x2, 0x3ac, 0x3ae, 0x7, 0x8, 0x2, 0x2, 0x3ad, 0x3af,
+ 0x7, 0x6f, 0x2, 0x2, 0x3ae, 0x3ad, 0x3, 0x2, 0x2, 0x2, 0x3ae, 0x3af,
+ 0x3, 0x2, 0x2, 0x2, 0x3af, 0x3b0, 0x3, 0x2, 0x2, 0x2, 0x3b0, 0x3b2,
+ 0x5, 0x7c, 0x3f, 0x2, 0x3b1, 0x3b3, 0x7, 0x6f, 0x2, 0x2, 0x3b2, 0x3b1,
+ 0x3, 0x2, 0x2, 0x2, 0x3b2, 0x3b3, 0x3, 0x2, 0x2, 0x2, 0x3b3, 0x3b4,
+ 0x3, 0x2, 0x2, 0x2, 0x3b4, 0x3b5, 0x7, 0x9, 0x2, 0x2, 0x3b5, 0x408,
+ 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b8, 0x7, 0x65, 0x2, 0x2, 0x3b7, 0x3b9,
+ 0x7, 0x6f, 0x2, 0x2, 0x3b8, 0x3b7, 0x3, 0x2, 0x2, 0x2, 0x3b8, 0x3b9,
+ 0x3, 0x2, 0x2, 0x2, 0x3b9, 0x3ba, 0x3, 0x2, 0x2, 0x2, 0x3ba, 0x3bc,
+ 0x7, 0x8, 0x2, 0x2, 0x3bb, 0x3bd, 0x7, 0x6f, 0x2, 0x2, 0x3bc, 0x3bb,
+ 0x3, 0x2, 0x2, 0x2, 0x3bc, 0x3bd, 0x3, 0x2, 0x2, 0x2, 0x3bd, 0x3be,
+ 0x3, 0x2, 0x2, 0x2, 0x3be, 0x3c0, 0x5, 0x7c, 0x3f, 0x2, 0x3bf, 0x3c1,
+ 0x7, 0x6f, 0x2, 0x2, 0x3c0, 0x3bf, 0x3, 0x2, 0x2, 0x2, 0x3c0, 0x3c1,
+ 0x3, 0x2, 0x2, 0x2, 0x3c1, 0x3c7, 0x3, 0x2, 0x2, 0x2, 0x3c2, 0x3c4,
+ 0x7, 0x6f, 0x2, 0x2, 0x3c3, 0x3c2, 0x3, 0x2, 0x2, 0x2, 0x3c3, 0x3c4,
+ 0x3, 0x2, 0x2, 0x2, 0x3c4, 0x3c5, 0x3, 0x2, 0x2, 0x2, 0x3c5, 0x3c6,
+ 0x7, 0xd, 0x2, 0x2, 0x3c6, 0x3c8, 0x5, 0x56, 0x2c, 0x2, 0x3c7, 0x3c3,
+ 0x3, 0x2, 0x2, 0x2, 0x3c7, 0x3c8, 0x3, 0x2, 0x2, 0x2, 0x3c8, 0x3c9,
+ 0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3ca, 0x7, 0x9, 0x2, 0x2, 0x3ca, 0x408,
+ 0x3, 0x2, 0x2, 0x2, 0x3cb, 0x3cd, 0x7, 0x41, 0x2, 0x2, 0x3cc, 0x3ce,
+ 0x7, 0x6f, 0x2, 0x2, 0x3cd, 0x3cc, 0x3, 0x2, 0x2, 0x2, 0x3cd, 0x3ce,
+ 0x3, 0x2, 0x2, 0x2, 0x3ce, 0x3cf, 0x3, 0x2, 0x2, 0x2, 0x3cf, 0x3d1,
+ 0x7, 0x8, 0x2, 0x2, 0x3d0, 0x3d2, 0x7, 0x6f, 0x2, 0x2, 0x3d1, 0x3d0,
+ 0x3, 0x2, 0x2, 0x2, 0x3d1, 0x3d2, 0x3, 0x2, 0x2, 0x2, 0x3d2, 0x3d3,
+ 0x3, 0x2, 0x2, 0x2, 0x3d3, 0x3d5, 0x5, 0x7c, 0x3f, 0x2, 0x3d4, 0x3d6,
+ 0x7, 0x6f, 0x2, 0x2, 0x3d5, 0x3d4, 0x3, 0x2, 0x2, 0x2, 0x3d5, 0x3d6,
+ 0x3, 0x2, 0x2, 0x2, 0x3d6, 0x3d7, 0x3, 0x2, 0x2, 0x2, 0x3d7, 0x3d8,
+ 0x7, 0x9, 0x2, 0x2, 0x3d8, 0x408, 0x3, 0x2, 0x2, 0x2, 0x3d9, 0x3db,
+ 0x7, 0x66, 0x2, 0x2, 0x3da, 0x3dc, 0x7, 0x6f, 0x2, 0x2, 0x3db, 0x3da,
+ 0x3, 0x2, 0x2, 0x2, 0x3db, 0x3dc, 0x3, 0x2, 0x2, 0x2, 0x3dc, 0x3dd,
+ 0x3, 0x2, 0x2, 0x2, 0x3dd, 0x3df, 0x7, 0x8, 0x2, 0x2, 0x3de, 0x3e0,
+ 0x7, 0x6f, 0x2, 0x2, 0x3df, 0x3de, 0x3, 0x2, 0x2, 0x2, 0x3df, 0x3e0,
+ 0x3, 0x2, 0x2, 0x2, 0x3e0, 0x3e1, 0x3, 0x2, 0x2, 0x2, 0x3e1, 0x3e3,
+ 0x5, 0x7c, 0x3f, 0x2, 0x3e2, 0x3e4, 0x7, 0x6f, 0x2, 0x2, 0x3e3, 0x3e2,
+ 0x3, 0x2, 0x2, 0x2, 0x3e3, 0x3e4, 0x3, 0x2, 0x2, 0x2, 0x3e4, 0x3e5,
+ 0x3, 0x2, 0x2, 0x2, 0x3e5, 0x3e6, 0x7, 0x9, 0x2, 0x2, 0x3e6, 0x408,
+ 0x3, 0x2, 0x2, 0x2, 0x3e7, 0x3e9, 0x7, 0x67, 0x2, 0x2, 0x3e8, 0x3ea,
+ 0x7, 0x6f, 0x2, 0x2, 0x3e9, 0x3e8, 0x3, 0x2, 0x2, 0x2, 0x3e9, 0x3ea,
+ 0x3, 0x2, 0x2, 0x2, 0x3ea, 0x3eb, 0x3, 0x2, 0x2, 0x2, 0x3eb, 0x3ed,
+ 0x7, 0x8, 0x2, 0x2, 0x3ec, 0x3ee, 0x7, 0x6f, 0x2, 0x2, 0x3ed, 0x3ec,
+ 0x3, 0x2, 0x2, 0x2, 0x3ed, 0x3ee, 0x3, 0x2, 0x2, 0x2, 0x3ee, 0x3ef,
+ 0x3, 0x2, 0x2, 0x2, 0x3ef, 0x3f1, 0x5, 0x7c, 0x3f, 0x2, 0x3f0, 0x3f2,
+ 0x7, 0x6f, 0x2, 0x2, 0x3f1, 0x3f0, 0x3, 0x2, 0x2, 0x2, 0x3f1, 0x3f2,
+ 0x3, 0x2, 0x2, 0x2, 0x3f2, 0x3f3, 0x3, 0x2, 0x2, 0x2, 0x3f3, 0x3f4,
+ 0x7, 0x9, 0x2, 0x2, 0x3f4, 0x408, 0x3, 0x2, 0x2, 0x2, 0x3f5, 0x3f7,
+ 0x7, 0x68, 0x2, 0x2, 0x3f6, 0x3f8, 0x7, 0x6f, 0x2, 0x2, 0x3f7, 0x3f6,
+ 0x3, 0x2, 0x2, 0x2, 0x3f7, 0x3f8, 0x3, 0x2, 0x2, 0x2, 0x3f8, 0x3f9,
+ 0x3, 0x2, 0x2, 0x2, 0x3f9, 0x3fb, 0x7, 0x8, 0x2, 0x2, 0x3fa, 0x3fc,
+ 0x7, 0x6f, 0x2, 0x2, 0x3fb, 0x3fa, 0x3, 0x2, 0x2, 0x2, 0x3fb, 0x3fc,
+ 0x3, 0x2, 0x2, 0x2, 0x3fc, 0x3fd, 0x3, 0x2, 0x2, 0x2, 0x3fd, 0x3ff,
+ 0x5, 0x7c, 0x3f, 0x2, 0x3fe, 0x400, 0x7, 0x6f, 0x2, 0x2, 0x3ff, 0x3fe,
+ 0x3, 0x2, 0x2, 0x2, 0x3ff, 0x400, 0x3, 0x2, 0x2, 0x2, 0x400, 0x401,
+ 0x3, 0x2, 0x2, 0x2, 0x401, 0x402, 0x7, 0x9, 0x2, 0x2, 0x402, 0x408,
+ 0x3, 0x2, 0x2, 0x2, 0x403, 0x408, 0x5, 0x7a, 0x3e, 0x2, 0x404, 0x408,
+ 0x5, 0x78, 0x3d, 0x2, 0x405, 0x408, 0x5, 0x80, 0x41, 0x2, 0x406, 0x408,
+ 0x5, 0x8a, 0x46, 0x2, 0x407, 0x397, 0x3, 0x2, 0x2, 0x2, 0x407, 0x398,
+ 0x3, 0x2, 0x2, 0x2, 0x407, 0x399, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3a6,
+ 0x3, 0x2, 0x2, 0x2, 0x407, 0x3a7, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3a8,
+ 0x3, 0x2, 0x2, 0x2, 0x407, 0x3b6, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3cb,
+ 0x3, 0x2, 0x2, 0x2, 0x407, 0x3d9, 0x3, 0x2, 0x2, 0x2, 0x407, 0x3e7,
+ 0x3, 0x2, 0x2, 0x2, 0x407, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0x407, 0x403,
+ 0x3, 0x2, 0x2, 0x2, 0x407, 0x404, 0x3, 0x2, 0x2, 0x2, 0x407, 0x405,
+ 0x3, 0x2, 0x2, 0x2, 0x407, 0x406, 0x3, 0x2, 0x2, 0x2, 0x408, 0x6f, 0x3,
+ 0x2, 0x2, 0x2, 0x409, 0x410, 0x5, 0x8c, 0x47, 0x2, 0x40a, 0x410, 0x7,
+ 0x32, 0x2, 0x2, 0x40b, 0x410, 0x5, 0x72, 0x3a, 0x2, 0x40c, 0x410, 0x7,
+ 0x62, 0x2, 0x2, 0x40d, 0x410, 0x5, 0x8e, 0x48, 0x2, 0x40e, 0x410, 0x5,
+ 0x74, 0x3b, 0x2, 0x40f, 0x409, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x40a, 0x3,
+ 0x2, 0x2, 0x2, 0x40f, 0x40b, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x40c, 0x3,
+ 0x2, 0x2, 0x2, 0x40f, 0x40d, 0x3, 0x2, 0x2, 0x2, 0x40f, 0x40e, 0x3,
+ 0x2, 0x2, 0x2, 0x410, 0x71, 0x3, 0x2, 0x2, 0x2, 0x411, 0x412, 0x9, 0x4,
+ 0x2, 0x2, 0x412, 0x73, 0x3, 0x2, 0x2, 0x2, 0x413, 0x415, 0x7, 0xa, 0x2,
+ 0x2, 0x414, 0x416, 0x7, 0x6f, 0x2, 0x2, 0x415, 0x414, 0x3, 0x2, 0x2,
+ 0x2, 0x415, 0x416, 0x3, 0x2, 0x2, 0x2, 0x416, 0x428, 0x3, 0x2, 0x2,
+ 0x2, 0x417, 0x419, 0x5, 0x56, 0x2c, 0x2, 0x418, 0x41a, 0x7, 0x6f, 0x2,
+ 0x2, 0x419, 0x418, 0x3, 0x2, 0x2, 0x2, 0x419, 0x41a, 0x3, 0x2, 0x2,
+ 0x2, 0x41a, 0x425, 0x3, 0x2, 0x2, 0x2, 0x41b, 0x41d, 0x7, 0x4, 0x2,
+ 0x2, 0x41c, 0x41e, 0x7, 0x6f, 0x2, 0x2, 0x41d, 0x41c, 0x3, 0x2, 0x2,
+ 0x2, 0x41d, 0x41e, 0x3, 0x2, 0x2, 0x2, 0x41e, 0x41f, 0x3, 0x2, 0x2,
+ 0x2, 0x41f, 0x421, 0x5, 0x56, 0x2c, 0x2, 0x420, 0x422, 0x7, 0x6f, 0x2,
+ 0x2, 0x421, 0x420, 0x3, 0x2, 0x2, 0x2, 0x421, 0x422, 0x3, 0x2, 0x2,
+ 0x2, 0x422, 0x424, 0x3, 0x2, 0x2, 0x2, 0x423, 0x41b, 0x3, 0x2, 0x2,
+ 0x2, 0x424, 0x427, 0x3, 0x2, 0x2, 0x2, 0x425, 0x423, 0x3, 0x2, 0x2,
+ 0x2, 0x425, 0x426, 0x3, 0x2, 0x2, 0x2, 0x426, 0x429, 0x3, 0x2, 0x2,
+ 0x2, 0x427, 0x425, 0x3, 0x2, 0x2, 0x2, 0x428, 0x417, 0x3, 0x2, 0x2,
+ 0x2, 0x428, 0x429, 0x3, 0x2, 0x2, 0x2, 0x429, 0x42a, 0x3, 0x2, 0x2,
+ 0x2, 0x42a, 0x42b, 0x7, 0xb, 0x2, 0x2, 0x42b, 0x75, 0x3, 0x2, 0x2, 0x2,
+ 0x42c, 0x42e, 0x7, 0x5, 0x2, 0x2, 0x42d, 0x42f, 0x7, 0x6f, 0x2, 0x2,
+ 0x42e, 0x42d, 0x3, 0x2, 0x2, 0x2, 0x42e, 0x42f, 0x3, 0x2, 0x2, 0x2,
+ 0x42f, 0x430, 0x3, 0x2, 0x2, 0x2, 0x430, 0x450, 0x5, 0x62, 0x32, 0x2,
+ 0x431, 0x433, 0x7, 0x15, 0x2, 0x2, 0x432, 0x434, 0x7, 0x6f, 0x2, 0x2,
+ 0x433, 0x432, 0x3, 0x2, 0x2, 0x2, 0x433, 0x434, 0x3, 0x2, 0x2, 0x2,
+ 0x434, 0x435, 0x3, 0x2, 0x2, 0x2, 0x435, 0x450, 0x5, 0x62, 0x32, 0x2,
+ 0x436, 0x438, 0x7, 0x16, 0x2, 0x2, 0x437, 0x439, 0x7, 0x6f, 0x2, 0x2,
+ 0x438, 0x437, 0x3, 0x2, 0x2, 0x2, 0x438, 0x439, 0x3, 0x2, 0x2, 0x2,
+ 0x439, 0x43a, 0x3, 0x2, 0x2, 0x2, 0x43a, 0x450, 0x5, 0x62, 0x32, 0x2,
+ 0x43b, 0x43d, 0x7, 0x17, 0x2, 0x2, 0x43c, 0x43e, 0x7, 0x6f, 0x2, 0x2,
+ 0x43d, 0x43c, 0x3, 0x2, 0x2, 0x2, 0x43d, 0x43e, 0x3, 0x2, 0x2, 0x2,
+ 0x43e, 0x43f, 0x3, 0x2, 0x2, 0x2, 0x43f, 0x450, 0x5, 0x62, 0x32, 0x2,
+ 0x440, 0x442, 0x7, 0x18, 0x2, 0x2, 0x441, 0x443, 0x7, 0x6f, 0x2, 0x2,
+ 0x442, 0x441, 0x3, 0x2, 0x2, 0x2, 0x442, 0x443, 0x3, 0x2, 0x2, 0x2,
+ 0x443, 0x444, 0x3, 0x2, 0x2, 0x2, 0x444, 0x450, 0x5, 0x62, 0x32, 0x2,
+ 0x445, 0x447, 0x7, 0x19, 0x2, 0x2, 0x446, 0x448, 0x7, 0x6f, 0x2, 0x2,
+ 0x447, 0x446, 0x3, 0x2, 0x2, 0x2, 0x447, 0x448, 0x3, 0x2, 0x2, 0x2,
+ 0x448, 0x449, 0x3, 0x2, 0x2, 0x2, 0x449, 0x450, 0x5, 0x62, 0x32, 0x2,
+ 0x44a, 0x44c, 0x7, 0x1a, 0x2, 0x2, 0x44b, 0x44d, 0x7, 0x6f, 0x2, 0x2,
+ 0x44c, 0x44b, 0x3, 0x2, 0x2, 0x2, 0x44c, 0x44d, 0x3, 0x2, 0x2, 0x2,
+ 0x44d, 0x44e, 0x3, 0x2, 0x2, 0x2, 0x44e, 0x450, 0x5, 0x62, 0x32, 0x2,
+ 0x44f, 0x42c, 0x3, 0x2, 0x2, 0x2, 0x44f, 0x431, 0x3, 0x2, 0x2, 0x2,
+ 0x44f, 0x436, 0x3, 0x2, 0x2, 0x2, 0x44f, 0x43b, 0x3, 0x2, 0x2, 0x2,
+ 0x44f, 0x440, 0x3, 0x2, 0x2, 0x2, 0x44f, 0x445, 0x3, 0x2, 0x2, 0x2,
+ 0x44f, 0x44a, 0x3, 0x2, 0x2, 0x2, 0x450, 0x77, 0x3, 0x2, 0x2, 0x2, 0x451,
+ 0x453, 0x7, 0x8, 0x2, 0x2, 0x452, 0x454, 0x7, 0x6f, 0x2, 0x2, 0x453,
+ 0x452, 0x3, 0x2, 0x2, 0x2, 0x453, 0x454, 0x3, 0x2, 0x2, 0x2, 0x454,
+ 0x455, 0x3, 0x2, 0x2, 0x2, 0x455, 0x457, 0x5, 0x56, 0x2c, 0x2, 0x456,
+ 0x458, 0x7, 0x6f, 0x2, 0x2, 0x457, 0x456, 0x3, 0x2, 0x2, 0x2, 0x457,
+ 0x458, 0x3, 0x2, 0x2, 0x2, 0x458, 0x459, 0x3, 0x2, 0x2, 0x2, 0x459,
+ 0x45a, 0x7, 0x9, 0x2, 0x2, 0x45a, 0x79, 0x3, 0x2, 0x2, 0x2, 0x45b, 0x460,
+ 0x5, 0x40, 0x21, 0x2, 0x45c, 0x45e, 0x7, 0x6f, 0x2, 0x2, 0x45d, 0x45c,
+ 0x3, 0x2, 0x2, 0x2, 0x45d, 0x45e, 0x3, 0x2, 0x2, 0x2, 0x45e, 0x45f,
+ 0x3, 0x2, 0x2, 0x2, 0x45f, 0x461, 0x5, 0x42, 0x22, 0x2, 0x460, 0x45d,
+ 0x3, 0x2, 0x2, 0x2, 0x461, 0x462, 0x3, 0x2, 0x2, 0x2, 0x462, 0x460,
+ 0x3, 0x2, 0x2, 0x2, 0x462, 0x463, 0x3, 0x2, 0x2, 0x2, 0x463, 0x7b, 0x3,
+ 0x2, 0x2, 0x2, 0x464, 0x469, 0x5, 0x7e, 0x40, 0x2, 0x465, 0x467, 0x7,
+ 0x6f, 0x2, 0x2, 0x466, 0x465, 0x3, 0x2, 0x2, 0x2, 0x466, 0x467, 0x3,
+ 0x2, 0x2, 0x2, 0x467, 0x468, 0x3, 0x2, 0x2, 0x2, 0x468, 0x46a, 0x5,
+ 0x36, 0x1c, 0x2, 0x469, 0x466, 0x3, 0x2, 0x2, 0x2, 0x469, 0x46a, 0x3,
+ 0x2, 0x2, 0x2, 0x46a, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x46b, 0x46c, 0x5, 0x8a,
+ 0x46, 0x2, 0x46c, 0x46d, 0x7, 0x6f, 0x2, 0x2, 0x46d, 0x46e, 0x7, 0x5d,
+ 0x2, 0x2, 0x46e, 0x46f, 0x7, 0x6f, 0x2, 0x2, 0x46f, 0x470, 0x5, 0x56,
+ 0x2c, 0x2, 0x470, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x471, 0x473, 0x5, 0x82,
+ 0x42, 0x2, 0x472, 0x474, 0x7, 0x6f, 0x2, 0x2, 0x473, 0x472, 0x3, 0x2,
+ 0x2, 0x2, 0x473, 0x474, 0x3, 0x2, 0x2, 0x2, 0x474, 0x475, 0x3, 0x2,
+ 0x2, 0x2, 0x475, 0x477, 0x7, 0x8, 0x2, 0x2, 0x476, 0x478, 0x7, 0x6f,
+ 0x2, 0x2, 0x477, 0x476, 0x3, 0x2, 0x2, 0x2, 0x477, 0x478, 0x3, 0x2,
+ 0x2, 0x2, 0x478, 0x47d, 0x3, 0x2, 0x2, 0x2, 0x479, 0x47b, 0x7, 0x4e,
+ 0x2, 0x2, 0x47a, 0x47c, 0x7, 0x6f, 0x2, 0x2, 0x47b, 0x47a, 0x3, 0x2,
+ 0x2, 0x2, 0x47b, 0x47c, 0x3, 0x2, 0x2, 0x2, 0x47c, 0x47e, 0x3, 0x2,
+ 0x2, 0x2, 0x47d, 0x479, 0x3, 0x2, 0x2, 0x2, 0x47d, 0x47e, 0x3, 0x2,
+ 0x2, 0x2, 0x47e, 0x490, 0x3, 0x2, 0x2, 0x2, 0x47f, 0x481, 0x5, 0x56,
+ 0x2c, 0x2, 0x480, 0x482, 0x7, 0x6f, 0x2, 0x2, 0x481, 0x480, 0x3, 0x2,
+ 0x2, 0x2, 0x481, 0x482, 0x3, 0x2, 0x2, 0x2, 0x482, 0x48d, 0x3, 0x2,
+ 0x2, 0x2, 0x483, 0x485, 0x7, 0x4, 0x2, 0x2, 0x484, 0x486, 0x7, 0x6f,
+ 0x2, 0x2, 0x485, 0x484, 0x3, 0x2, 0x2, 0x2, 0x485, 0x486, 0x3, 0x2,
+ 0x2, 0x2, 0x486, 0x487, 0x3, 0x2, 0x2, 0x2, 0x487, 0x489, 0x5, 0x56,
+ 0x2c, 0x2, 0x488, 0x48a, 0x7, 0x6f, 0x2, 0x2, 0x489, 0x488, 0x3, 0x2,
+ 0x2, 0x2, 0x489, 0x48a, 0x3, 0x2, 0x2, 0x2, 0x48a, 0x48c, 0x3, 0x2,
+ 0x2, 0x2, 0x48b, 0x483, 0x3, 0x2, 0x2, 0x2, 0x48c, 0x48f, 0x3, 0x2,
+ 0x2, 0x2, 0x48d, 0x48b, 0x3, 0x2, 0x2, 0x2, 0x48d, 0x48e, 0x3, 0x2,
+ 0x2, 0x2, 0x48e, 0x491, 0x3, 0x2, 0x2, 0x2, 0x48f, 0x48d, 0x3, 0x2,
+ 0x2, 0x2, 0x490, 0x47f, 0x3, 0x2, 0x2, 0x2, 0x490, 0x491, 0x3, 0x2,
+ 0x2, 0x2, 0x491, 0x492, 0x3, 0x2, 0x2, 0x2, 0x492, 0x493, 0x7, 0x9,
+ 0x2, 0x2, 0x493, 0x81, 0x3, 0x2, 0x2, 0x2, 0x494, 0x495, 0x9, 0x5, 0x2,
+ 0x2, 0x495, 0x83, 0x3, 0x2, 0x2, 0x2, 0x496, 0x498, 0x7, 0xa, 0x2, 0x2,
+ 0x497, 0x499, 0x7, 0x6f, 0x2, 0x2, 0x498, 0x497, 0x3, 0x2, 0x2, 0x2,
+ 0x498, 0x499, 0x3, 0x2, 0x2, 0x2, 0x499, 0x49a, 0x3, 0x2, 0x2, 0x2,
+ 0x49a, 0x4a3, 0x5, 0x7c, 0x3f, 0x2, 0x49b, 0x49d, 0x7, 0x6f, 0x2, 0x2,
+ 0x49c, 0x49b, 0x3, 0x2, 0x2, 0x2, 0x49c, 0x49d, 0x3, 0x2, 0x2, 0x2,
+ 0x49d, 0x49e, 0x3, 0x2, 0x2, 0x2, 0x49e, 0x4a0, 0x7, 0xd, 0x2, 0x2,
+ 0x49f, 0x4a1, 0x7, 0x6f, 0x2, 0x2, 0x4a0, 0x49f, 0x3, 0x2, 0x2, 0x2,
+ 0x4a0, 0x4a1, 0x3, 0x2, 0x2, 0x2, 0x4a1, 0x4a2, 0x3, 0x2, 0x2, 0x2,
+ 0x4a2, 0x4a4, 0x5, 0x56, 0x2c, 0x2, 0x4a3, 0x49c, 0x3, 0x2, 0x2, 0x2,
+ 0x4a3, 0x4a4, 0x3, 0x2, 0x2, 0x2, 0x4a4, 0x4a6, 0x3, 0x2, 0x2, 0x2,
+ 0x4a5, 0x4a7, 0x7, 0x6f, 0x2, 0x2, 0x4a6, 0x4a5, 0x3, 0x2, 0x2, 0x2,
+ 0x4a6, 0x4a7, 0x3, 0x2, 0x2, 0x2, 0x4a7, 0x4a8, 0x3, 0x2, 0x2, 0x2,
+ 0x4a8, 0x4a9, 0x7, 0xb, 0x2, 0x2, 0x4a9, 0x85, 0x3, 0x2, 0x2, 0x2, 0x4aa,
+ 0x4ac, 0x7, 0xa, 0x2, 0x2, 0x4ab, 0x4ad, 0x7, 0x6f, 0x2, 0x2, 0x4ac,
+ 0x4ab, 0x3, 0x2, 0x2, 0x2, 0x4ac, 0x4ad, 0x3, 0x2, 0x2, 0x2, 0x4ad,
+ 0x4b6, 0x3, 0x2, 0x2, 0x2, 0x4ae, 0x4b0, 0x5, 0x8a, 0x46, 0x2, 0x4af,
+ 0x4b1, 0x7, 0x6f, 0x2, 0x2, 0x4b0, 0x4af, 0x3, 0x2, 0x2, 0x2, 0x4b0,
+ 0x4b1, 0x3, 0x2, 0x2, 0x2, 0x4b1, 0x4b2, 0x3, 0x2, 0x2, 0x2, 0x4b2,
+ 0x4b4, 0x7, 0x5, 0x2, 0x2, 0x4b3, 0x4b5, 0x7, 0x6f, 0x2, 0x2, 0x4b4,
+ 0x4b3, 0x3, 0x2, 0x2, 0x2, 0x4b4, 0x4b5, 0x3, 0x2, 0x2, 0x2, 0x4b5,
+ 0x4b7, 0x3, 0x2, 0x2, 0x2, 0x4b6, 0x4ae, 0x3, 0x2, 0x2, 0x2, 0x4b6,
+ 0x4b7, 0x3, 0x2, 0x2, 0x2, 0x4b7, 0x4b8, 0x3, 0x2, 0x2, 0x2, 0x4b8,
+ 0x4ba, 0x5, 0x7a, 0x3e, 0x2, 0x4b9, 0x4bb, 0x7, 0x6f, 0x2, 0x2, 0x4ba,
+ 0x4b9, 0x3, 0x2, 0x2, 0x2, 0x4ba, 0x4bb, 0x3, 0x2, 0x2, 0x2, 0x4bb,
+ 0x4c4, 0x3, 0x2, 0x2, 0x2, 0x4bc, 0x4be, 0x7, 0x58, 0x2, 0x2, 0x4bd,
+ 0x4bf, 0x7, 0x6f, 0x2, 0x2, 0x4be, 0x4bd, 0x3, 0x2, 0x2, 0x2, 0x4be,
+ 0x4bf, 0x3, 0x2, 0x2, 0x2, 0x4bf, 0x4c0, 0x3, 0x2, 0x2, 0x2, 0x4c0,
+ 0x4c2, 0x5, 0x56, 0x2c, 0x2, 0x4c1, 0x4c3, 0x7, 0x6f, 0x2, 0x2, 0x4c2,
+ 0x4c1, 0x3, 0x2, 0x2, 0x2, 0x4c2, 0x4c3, 0x3, 0x2, 0x2, 0x2, 0x4c3,
+ 0x4c5, 0x3, 0x2, 0x2, 0x2, 0x4c4, 0x4bc, 0x3, 0x2, 0x2, 0x2, 0x4c4,
+ 0x4c5, 0x3, 0x2, 0x2, 0x2, 0x4c5, 0x4c6, 0x3, 0x2, 0x2, 0x2, 0x4c6,
+ 0x4c8, 0x7, 0xd, 0x2, 0x2, 0x4c7, 0x4c9, 0x7, 0x6f, 0x2, 0x2, 0x4c8,
+ 0x4c7, 0x3, 0x2, 0x2, 0x2, 0x4c8, 0x4c9, 0x3, 0x2, 0x2, 0x2, 0x4c9,
+ 0x4ca, 0x3, 0x2, 0x2, 0x2, 0x4ca, 0x4cc, 0x5, 0x56, 0x2c, 0x2, 0x4cb,
+ 0x4cd, 0x7, 0x6f, 0x2, 0x2, 0x4cc, 0x4cb, 0x3, 0x2, 0x2, 0x2, 0x4cc,
+ 0x4cd, 0x3, 0x2, 0x2, 0x2, 0x4cd, 0x4ce, 0x3, 0x2, 0x2, 0x2, 0x4ce,
+ 0x4cf, 0x7, 0xb, 0x2, 0x2, 0x4cf, 0x87, 0x3, 0x2, 0x2, 0x2, 0x4d0, 0x4d2,
+ 0x7, 0x1b, 0x2, 0x2, 0x4d1, 0x4d3, 0x7, 0x6f, 0x2, 0x2, 0x4d2, 0x4d1,
+ 0x3, 0x2, 0x2, 0x2, 0x4d2, 0x4d3, 0x3, 0x2, 0x2, 0x2, 0x4d3, 0x4d4,
+ 0x3, 0x2, 0x2, 0x2, 0x4d4, 0x4d5, 0x5, 0x94, 0x4b, 0x2, 0x4d5, 0x89,
+ 0x3, 0x2, 0x2, 0x2, 0x4d6, 0x4d7, 0x5, 0x9a, 0x4e, 0x2, 0x4d7, 0x8b,
+ 0x3, 0x2, 0x2, 0x2, 0x4d8, 0x4db, 0x5, 0x98, 0x4d, 0x2, 0x4d9, 0x4db,
+ 0x5, 0x96, 0x4c, 0x2, 0x4da, 0x4d8, 0x3, 0x2, 0x2, 0x2, 0x4da, 0x4d9,
+ 0x3, 0x2, 0x2, 0x2, 0x4db, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x4dc, 0x4de, 0x7,
+ 0x1c, 0x2, 0x2, 0x4dd, 0x4df, 0x7, 0x6f, 0x2, 0x2, 0x4de, 0x4dd, 0x3,
+ 0x2, 0x2, 0x2, 0x4de, 0x4df, 0x3, 0x2, 0x2, 0x2, 0x4df, 0x501, 0x3,
+ 0x2, 0x2, 0x2, 0x4e0, 0x4e2, 0x5, 0x94, 0x4b, 0x2, 0x4e1, 0x4e3, 0x7,
+ 0x6f, 0x2, 0x2, 0x4e2, 0x4e1, 0x3, 0x2, 0x2, 0x2, 0x4e2, 0x4e3, 0x3,
+ 0x2, 0x2, 0x2, 0x4e3, 0x4e4, 0x3, 0x2, 0x2, 0x2, 0x4e4, 0x4e6, 0x7,
+ 0xc, 0x2, 0x2, 0x4e5, 0x4e7, 0x7, 0x6f, 0x2, 0x2, 0x4e6, 0x4e5, 0x3,
+ 0x2, 0x2, 0x2, 0x4e6, 0x4e7, 0x3, 0x2, 0x2, 0x2, 0x4e7, 0x4e8, 0x3,
+ 0x2, 0x2, 0x2, 0x4e8, 0x4ea, 0x5, 0x56, 0x2c, 0x2, 0x4e9, 0x4eb, 0x7,
+ 0x6f, 0x2, 0x2, 0x4ea, 0x4e9, 0x3, 0x2, 0x2, 0x2, 0x4ea, 0x4eb, 0x3,
+ 0x2, 0x2, 0x2, 0x4eb, 0x4fe, 0x3, 0x2, 0x2, 0x2, 0x4ec, 0x4ee, 0x7,
+ 0x4, 0x2, 0x2, 0x4ed, 0x4ef, 0x7, 0x6f, 0x2, 0x2, 0x4ee, 0x4ed, 0x3,
+ 0x2, 0x2, 0x2, 0x4ee, 0x4ef, 0x3, 0x2, 0x2, 0x2, 0x4ef, 0x4f0, 0x3,
+ 0x2, 0x2, 0x2, 0x4f0, 0x4f2, 0x5, 0x94, 0x4b, 0x2, 0x4f1, 0x4f3, 0x7,
+ 0x6f, 0x2, 0x2, 0x4f2, 0x4f1, 0x3, 0x2, 0x2, 0x2, 0x4f2, 0x4f3, 0x3,
+ 0x2, 0x2, 0x2, 0x4f3, 0x4f4, 0x3, 0x2, 0x2, 0x2, 0x4f4, 0x4f6, 0x7,
+ 0xc, 0x2, 0x2, 0x4f5, 0x4f7, 0x7, 0x6f, 0x2, 0x2, 0x4f6, 0x4f5, 0x3,
+ 0x2, 0x2, 0x2, 0x4f6, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4f7, 0x4f8, 0x3,
+ 0x2, 0x2, 0x2, 0x4f8, 0x4fa, 0x5, 0x56, 0x2c, 0x2, 0x4f9, 0x4fb, 0x7,
+ 0x6f, 0x2, 0x2, 0x4fa, 0x4f9, 0x3, 0x2, 0x2, 0x2, 0x4fa, 0x4fb, 0x3,
+ 0x2, 0x2, 0x2, 0x4fb, 0x4fd, 0x3, 0x2, 0x2, 0x2, 0x4fc, 0x4ec, 0x3,
+ 0x2, 0x2, 0x2, 0x4fd, 0x500, 0x3, 0x2, 0x2, 0x2, 0x4fe, 0x4fc, 0x3,
+ 0x2, 0x2, 0x2, 0x4fe, 0x4ff, 0x3, 0x2, 0x2, 0x2, 0x4ff, 0x502, 0x3,
+ 0x2, 0x2, 0x2, 0x500, 0x4fe, 0x3, 0x2, 0x2, 0x2, 0x501, 0x4e0, 0x3,
+ 0x2, 0x2, 0x2, 0x501, 0x502, 0x3, 0x2, 0x2, 0x2, 0x502, 0x503, 0x3,
+ 0x2, 0x2, 0x2, 0x503, 0x504, 0x7, 0x1d, 0x2, 0x2, 0x504, 0x8f, 0x3,
+ 0x2, 0x2, 0x2, 0x505, 0x508, 0x7, 0x1e, 0x2, 0x2, 0x506, 0x509, 0x5,
+ 0x9a, 0x4e, 0x2, 0x507, 0x509, 0x7, 0x35, 0x2, 0x2, 0x508, 0x506, 0x3,
+ 0x2, 0x2, 0x2, 0x508, 0x507, 0x3, 0x2, 0x2, 0x2, 0x509, 0x91, 0x3, 0x2,
+ 0x2, 0x2, 0x50a, 0x50f, 0x5, 0x6e, 0x38, 0x2, 0x50b, 0x50d, 0x7, 0x6f,
+ 0x2, 0x2, 0x50c, 0x50b, 0x3, 0x2, 0x2, 0x2, 0x50c, 0x50d, 0x3, 0x2,
+ 0x2, 0x2, 0x50d, 0x50e, 0x3, 0x2, 0x2, 0x2, 0x50e, 0x510, 0x5, 0x88,
+ 0x45, 0x2, 0x50f, 0x50c, 0x3, 0x2, 0x2, 0x2, 0x510, 0x511, 0x3, 0x2,
+ 0x2, 0x2, 0x511, 0x50f, 0x3, 0x2, 0x2, 0x2, 0x511, 0x512, 0x3, 0x2,
+ 0x2, 0x2, 0x512, 0x93, 0x3, 0x2, 0x2, 0x2, 0x513, 0x514, 0x5, 0x9a,
+ 0x4e, 0x2, 0x514, 0x95, 0x3, 0x2, 0x2, 0x2, 0x515, 0x516, 0x9, 0x6,
+ 0x2, 0x2, 0x516, 0x97, 0x3, 0x2, 0x2, 0x2, 0x517, 0x518, 0x9, 0x7, 0x2,
+ 0x2, 0x518, 0x99, 0x3, 0x2, 0x2, 0x2, 0x519, 0x51a, 0x9, 0x8, 0x2, 0x2,
+ 0x51a, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x51b, 0x51c, 0x9, 0x9, 0x2, 0x2, 0x51c,
+ 0x9d, 0x3, 0x2, 0x2, 0x2, 0x51d, 0x51e, 0x9, 0xa, 0x2, 0x2, 0x51e, 0x9f,
+ 0x3, 0x2, 0x2, 0x2, 0x51f, 0x520, 0x9, 0xb, 0x2, 0x2, 0x520, 0xa1, 0x3,
+ 0x2, 0x2, 0x2, 0xf3, 0xa3, 0xa7, 0xaa, 0xad, 0xb5, 0xba, 0xbf, 0xc4,
+ 0xcb, 0xd0, 0xd3, 0xde, 0xe2, 0xe6, 0xea, 0xed, 0xf1, 0xfb, 0x102, 0x10f,
+ 0x113, 0x119, 0x120, 0x125, 0x129, 0x12f, 0x133, 0x139, 0x13d, 0x143,
+ 0x147, 0x14b, 0x14f, 0x153, 0x157, 0x15c, 0x163, 0x167, 0x16c, 0x173,
+ 0x177, 0x17a, 0x17f, 0x182, 0x186, 0x189, 0x191, 0x195, 0x199, 0x19d,
+ 0x1a1, 0x1a6, 0x1ab, 0x1af, 0x1b4, 0x1b7, 0x1c0, 0x1c9, 0x1ce, 0x1db,
+ 0x1de, 0x1e6, 0x1ea, 0x1ef, 0x1f4, 0x1f8, 0x1fd, 0x203, 0x208, 0x20f,
+ 0x213, 0x217, 0x219, 0x21d, 0x21f, 0x223, 0x225, 0x22b, 0x231, 0x235,
+ 0x238, 0x23b, 0x23f, 0x245, 0x249, 0x24c, 0x24f, 0x255, 0x258, 0x25b,
+ 0x25f, 0x265, 0x268, 0x26b, 0x26f, 0x273, 0x277, 0x279, 0x27d, 0x27f,
+ 0x282, 0x286, 0x288, 0x28e, 0x292, 0x296, 0x29a, 0x29d, 0x2a2, 0x2a7,
+ 0x2ac, 0x2b1, 0x2b7, 0x2bb, 0x2bd, 0x2c1, 0x2c5, 0x2c7, 0x2c9, 0x2d8,
+ 0x2e2, 0x2ec, 0x2f1, 0x2f5, 0x2fc, 0x301, 0x306, 0x30a, 0x30e, 0x312,
+ 0x315, 0x317, 0x31c, 0x320, 0x324, 0x328, 0x32c, 0x330, 0x333, 0x335,
+ 0x33a, 0x33e, 0x343, 0x348, 0x34c, 0x353, 0x35a, 0x35e, 0x362, 0x366,
+ 0x375, 0x378, 0x385, 0x387, 0x38c, 0x390, 0x394, 0x39b, 0x39f, 0x3a3,
+ 0x3aa, 0x3ae, 0x3b2, 0x3b8, 0x3bc, 0x3c0, 0x3c3, 0x3c7, 0x3cd, 0x3d1,
+ 0x3d5, 0x3db, 0x3df, 0x3e3, 0x3e9, 0x3ed, 0x3f1, 0x3f7, 0x3fb, 0x3ff,
+ 0x407, 0x40f, 0x415, 0x419, 0x41d, 0x421, 0x425, 0x428, 0x42e, 0x433,
+ 0x438, 0x43d, 0x442, 0x447, 0x44c, 0x44f, 0x453, 0x457, 0x45d, 0x462,
+ 0x466, 0x469, 0x473, 0x477, 0x47b, 0x47d, 0x481, 0x485, 0x489, 0x48d,
+ 0x490, 0x498, 0x49c, 0x4a0, 0x4a3, 0x4a6, 0x4ac, 0x4b0, 0x4b4, 0x4b6,
+ 0x4ba, 0x4be, 0x4c2, 0x4c4, 0x4c8, 0x4cc, 0x4d2, 0x4da, 0x4de, 0x4e2,
+ 0x4e6, 0x4ea, 0x4ee, 0x4f2, 0x4f6, 0x4fa, 0x4fe, 0x501, 0x508, 0x50c,
+ 0x511,
};
atn::ATNDeserializer deserializer;
@@ -10680,7 +10619,7 @@ CypherParser::Initializer::Initializer() {
size_t count = _atn.getNumberOfDecisions();
_decisionToDFA.reserve(count);
- for (size_t i = 0; i < count; i++) {
+ for (size_t i = 0; i < count; i++) {
_decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
}
}
diff --git a/src/query/frontend/opencypher/generated/CypherParser.h b/src/query/frontend/opencypher/generated/CypherParser.h
index 1c3cdb243..ad6859560 100644
--- a/src/query/frontend/opencypher/generated/CypherParser.h
+++ b/src/query/frontend/opencypher/generated/CypherParser.h
@@ -1,5 +1,5 @@
-// Generated from /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
#pragma once
@@ -20,20 +20,19 @@ public:
T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32,
T__32 = 33, T__33 = 34, T__34 = 35, T__35 = 36, T__36 = 37, T__37 = 38,
T__38 = 39, T__39 = 40, T__40 = 41, T__41 = 42, T__42 = 43, T__43 = 44,
- T__44 = 45, T__45 = 46, T__46 = 47, T__47 = 48, T__48 = 49, StringLiteral = 50,
- EscapedChar = 51, HexInteger = 52, DecimalInteger = 53, OctalInteger = 54,
- HexLetter = 55, HexDigit = 56, Digit = 57, NonZeroDigit = 58, NonZeroOctDigit = 59,
- OctDigit = 60, ZeroDigit = 61, ExponentDecimalReal = 62, RegularDecimalReal = 63,
- UNION = 64, ALL = 65, OPTIONAL = 66, MATCH = 67, UNWIND = 68, AS = 69,
- MERGE = 70, ON = 71, CREATE = 72, SET = 73, DETACH = 74, DELETE = 75,
- REMOVE = 76, WITH = 77, DISTINCT = 78, RETURN = 79, ORDER = 80, BY = 81,
- L_SKIP = 82, LIMIT = 83, ASCENDING = 84, ASC = 85, DESCENDING = 86,
- DESC = 87, WHERE = 88, OR = 89, XOR = 90, AND = 91, NOT = 92, IN = 93,
- STARTS = 94, ENDS = 95, CONTAINS = 96, IS = 97, CYPHERNULL = 98, COUNT = 99,
- FILTER = 100, EXTRACT = 101, ANY = 102, NONE = 103, SINGLE = 104, TRUE = 105,
- FALSE = 106, UnescapedSymbolicName = 107, IdentifierStart = 108, IdentifierPart = 109,
- EscapedSymbolicName = 110, SP = 111, WHITESPACE = 112, Comment = 113,
- L_0X = 114
+ T__44 = 45, T__45 = 46, T__46 = 47, StringLiteral = 48, EscapedChar = 49,
+ HexInteger = 50, DecimalInteger = 51, OctalInteger = 52, HexLetter = 53,
+ HexDigit = 54, Digit = 55, NonZeroDigit = 56, NonZeroOctDigit = 57,
+ OctDigit = 58, ZeroDigit = 59, ExponentDecimalReal = 60, RegularDecimalReal = 61,
+ UNION = 62, ALL = 63, OPTIONAL = 64, MATCH = 65, UNWIND = 66, AS = 67,
+ MERGE = 68, ON = 69, CREATE = 70, SET = 71, DETACH = 72, DELETE = 73,
+ REMOVE = 74, WITH = 75, DISTINCT = 76, RETURN = 77, ORDER = 78, BY = 79,
+ L_SKIP = 80, LIMIT = 81, ASCENDING = 82, ASC = 83, DESCENDING = 84,
+ DESC = 85, WHERE = 86, OR = 87, XOR = 88, AND = 89, NOT = 90, IN = 91,
+ STARTS = 92, ENDS = 93, CONTAINS = 94, IS = 95, CYPHERNULL = 96, COUNT = 97,
+ FILTER = 98, EXTRACT = 99, ANY = 100, NONE = 101, SINGLE = 102, TRUE = 103,
+ FALSE = 104, UnescapedSymbolicName = 105, IdentifierStart = 106, IdentifierPart = 107,
+ EscapedSymbolicName = 108, SP = 109, WHITESPACE = 110, Comment = 111
};
enum {
@@ -55,11 +54,11 @@ public:
RuleListLiteral = 57, RulePartialComparisonExpression = 58, RuleParenthesizedExpression = 59,
RuleRelationshipsPattern = 60, RuleFilterExpression = 61, RuleIdInColl = 62,
RuleFunctionInvocation = 63, RuleFunctionName = 64, RuleListComprehension = 65,
- RulePropertyLookup = 66, RuleVariable = 67, RuleNumberLiteral = 68,
- RuleMapLiteral = 69, RuleParameter = 70, RulePropertyExpression = 71,
- RulePropertyKeyName = 72, RuleIntegerLiteral = 73, RuleDoubleLiteral = 74,
- RuleSymbolicName = 75, RuleLeftArrowHead = 76, RuleRightArrowHead = 77,
- RuleDash = 78
+ RulePatternComprehension = 66, RulePropertyLookup = 67, RuleVariable = 68,
+ RuleNumberLiteral = 69, RuleMapLiteral = 70, RuleParameter = 71, RulePropertyExpression = 72,
+ RulePropertyKeyName = 73, RuleIntegerLiteral = 74, RuleDoubleLiteral = 75,
+ RuleSymbolicName = 76, RuleLeftArrowHead = 77, RuleRightArrowHead = 78,
+ RuleDash = 79
};
CypherParser(antlr4::TokenStream *input);
@@ -138,6 +137,7 @@ public:
class FunctionInvocationContext;
class FunctionNameContext;
class ListComprehensionContext;
+ class PatternComprehensionContext;
class PropertyLookupContext;
class VariableContext;
class NumberLiteralContext;
@@ -382,6 +382,7 @@ public:
antlr4::tree::TerminalNode *SET();
std::vector<SetItemContext *> setItem();
SetItemContext* setItem(size_t i);
+ antlr4::tree::TerminalNode *SP();
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
@@ -398,6 +399,8 @@ public:
virtual size_t getRuleIndex() const override;
PropertyExpressionContext *propertyExpression();
ExpressionContext *expression();
+ std::vector<antlr4::tree::TerminalNode *> SP();
+ antlr4::tree::TerminalNode* SP(size_t i);
VariableContext *variable();
NodeLabelsContext *nodeLabels();
@@ -785,6 +788,8 @@ public:
public:
RelationshipDetailContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
+ std::vector<antlr4::tree::TerminalNode *> SP();
+ antlr4::tree::TerminalNode* SP(size_t i);
VariableContext *variable();
RelationshipTypesContext *relationshipTypes();
RangeLiteralContext *rangeLiteral();
@@ -856,6 +861,7 @@ public:
NodeLabelContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
LabelNameContext *labelName();
+ antlr4::tree::TerminalNode *SP();
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
@@ -1143,6 +1149,8 @@ public:
PropertyLookupContext* propertyLookup(size_t i);
std::vector<NodeLabelsContext *> nodeLabels();
NodeLabelsContext* nodeLabels(size_t i);
+ std::vector<antlr4::tree::TerminalNode *> SP();
+ antlr4::tree::TerminalNode* SP(size_t i);
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
@@ -1163,6 +1171,7 @@ public:
std::vector<antlr4::tree::TerminalNode *> SP();
antlr4::tree::TerminalNode* SP(size_t i);
ListComprehensionContext *listComprehension();
+ PatternComprehensionContext *patternComprehension();
antlr4::tree::TerminalNode *FILTER();
FilterExpressionContext *filterExpression();
antlr4::tree::TerminalNode *EXTRACT();
@@ -1382,13 +1391,33 @@ public:
ListComprehensionContext* listComprehension();
+ class PatternComprehensionContext : public antlr4::ParserRuleContext {
+ public:
+ PatternComprehensionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
+ virtual size_t getRuleIndex() const override;
+ RelationshipsPatternContext *relationshipsPattern();
+ std::vector<ExpressionContext *> expression();
+ ExpressionContext* expression(size_t i);
+ std::vector<antlr4::tree::TerminalNode *> SP();
+ antlr4::tree::TerminalNode* SP(size_t i);
+ VariableContext *variable();
+ antlr4::tree::TerminalNode *WHERE();
+
+ virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
+ virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
+
+ virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+
+ };
+
+ PatternComprehensionContext* patternComprehension();
+
class PropertyLookupContext : public antlr4::ParserRuleContext {
public:
PropertyLookupContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
PropertyKeyNameContext *propertyKeyName();
- std::vector<antlr4::tree::TerminalNode *> SP();
- antlr4::tree::TerminalNode* SP(size_t i);
+ antlr4::tree::TerminalNode *SP();
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
diff --git a/src/query/frontend/opencypher/generated/CypherVisitor.cpp b/src/query/frontend/opencypher/generated/CypherVisitor.cpp
index d001e27a4..085ce56dd 100644
--- a/src/query/frontend/opencypher/generated/CypherVisitor.cpp
+++ b/src/query/frontend/opencypher/generated/CypherVisitor.cpp
@@ -1,8 +1,9 @@
-// Generated from
-// /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4
-// by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+
#include "CypherVisitor.h"
+
using namespace antlropencypher;
+
diff --git a/src/query/frontend/opencypher/generated/CypherVisitor.h b/src/query/frontend/opencypher/generated/CypherVisitor.h
index 78628d080..80936bedf 100644
--- a/src/query/frontend/opencypher/generated/CypherVisitor.h
+++ b/src/query/frontend/opencypher/generated/CypherVisitor.h
@@ -1,5 +1,5 @@
-// Generated from /home/buda/Workspace/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
+// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6
#pragma once
@@ -152,6 +152,8 @@ public:
virtual antlrcpp::Any visitListComprehension(CypherParser::ListComprehensionContext *context) = 0;
+ virtual antlrcpp::Any visitPatternComprehension(CypherParser::PatternComprehensionContext *context) = 0;
+
virtual antlrcpp::Any visitPropertyLookup(CypherParser::PropertyLookupContext *context) = 0;
virtual antlrcpp::Any visitVariable(CypherParser::VariableContext *context) = 0;
diff --git a/src/query/frontend/opencypher/grammar/Cypher.g4 b/src/query/frontend/opencypher/grammar/Cypher.g4
index 1c0a8d431..6d2576229 100644
--- a/src/query/frontend/opencypher/grammar/Cypher.g4
+++ b/src/query/frontend/opencypher/grammar/Cypher.g4
@@ -53,12 +53,12 @@ mergeAction : ( ON SP MATCH SP set )
create : CREATE SP? pattern ;
-set : SET setItem ( ',' setItem )* ;
+set : SET SP? setItem ( ',' setItem )* ;
-setItem : ( propertyExpression '=' expression )
- | ( variable '=' expression )
- | ( variable '+=' expression )
- | ( variable nodeLabels )
+setItem : ( propertyExpression SP? '=' SP? expression )
+ | ( variable SP? '=' SP? expression )
+ | ( variable SP? '+=' SP? expression )
+ | ( variable SP? nodeLabels )
;
cypherDelete : ( DETACH SP )? DELETE SP? expression ( SP? ',' SP? expression )* ;
@@ -115,17 +115,17 @@ relationshipPattern : ( leftArrowHead SP? dash SP? relationshipDetail? SP? dash
| ( dash SP? relationshipDetail? SP? dash )
;
-relationshipDetail : '[' variable? '?'? relationshipTypes? rangeLiteral? properties? ']' ;
+relationshipDetail : '[' SP? ( variable SP? )? ( relationshipTypes SP? )? rangeLiteral? ( properties SP? )? ']' ;
properties : mapLiteral
| parameter
;
-relationshipTypes : ':' relTypeName ( SP? '|' ':'? SP? relTypeName )* ;
+relationshipTypes : ':' SP? relTypeName ( SP? '|' ':'? SP? relTypeName )* ;
nodeLabels : nodeLabel ( SP? nodeLabel )* ;
-nodeLabel : ':' labelName ;
+nodeLabel : ':' SP? labelName ;
rangeLiteral : '*' SP? ( integerLiteral SP? )? ( '..' SP? ( integerLiteral SP? )? )? ;
@@ -155,12 +155,13 @@ expression4 : ( ( '+' | '-' ) SP? )* expression3 ;
expression3 : expression2 ( ( SP? '[' expression ']' ) | ( SP? '[' expression? '..' expression? ']' ) | ( ( ( SP? '=~' ) | ( SP IN ) | ( SP STARTS SP WITH ) | ( SP ENDS SP WITH ) | ( SP CONTAINS ) ) SP? expression2 ) | ( SP IS SP CYPHERNULL ) | ( SP IS SP NOT SP CYPHERNULL ) )* ;
-expression2 : atom ( propertyLookup | nodeLabels )* ;
+expression2 : atom ( SP? ( propertyLookup | nodeLabels ) )* ;
atom : literal
| parameter
| ( COUNT SP? '(' SP? '*' SP? ')' )
| listComprehension
+ | patternComprehension
| ( FILTER SP? '(' SP? filterExpression SP? ')' )
| ( EXTRACT SP? '(' SP? filterExpression SP? ( SP? '|' expression )? ')' )
| ( ALL SP? '(' SP? filterExpression SP? ')' )
@@ -212,7 +213,9 @@ functionName : UnescapedSymbolicName
listComprehension : '[' SP? filterExpression ( SP? '|' SP? expression )? SP? ']' ;
-propertyLookup : SP? '.' SP? ( ( propertyKeyName ( '?' | '!' ) ) | propertyKeyName ) ;
+patternComprehension : '[' SP? ( variable SP? '=' SP? )? relationshipsPattern SP? ( WHERE SP? expression SP? )? '|' SP? expression SP? ']' ;
+
+propertyLookup : '.' SP? ( propertyKeyName ) ;
variable : symbolicName ;
@@ -220,7 +223,7 @@ StringLiteral : ( '"' ( StringLiteral_0 | EscapedChar )* '"' )
| ( '\'' ( StringLiteral_1 | EscapedChar )* '\'' )
;
-EscapedChar : '\\' ( '\\' | '\'' | '"' | ( 'B' | 'b' ) | ( 'F' | 'f' ) | ( 'N' | 'n' ) | ( 'R' | 'r' ) | ( 'T' | 't' ) | '_' | '%' | ( ( 'U' | 'u' ) ( HexDigit HexDigit HexDigit HexDigit ) ) | ( ( 'U' | 'u' ) ( HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit ) ) ) ;
+EscapedChar : '\\' ( '\\' | '\'' | '"' | ( 'B' | 'b' ) | ( 'F' | 'f' ) | ( 'N' | 'n' ) | ( 'R' | 'r' ) | ( 'T' | 't' ) | ( ( 'U' | 'u' ) ( HexDigit HexDigit HexDigit HexDigit ) ) | ( ( 'U' | 'u' ) ( HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit ) ) ) ;
numberLiteral : doubleLiteral
| integerLiteral
@@ -239,7 +242,7 @@ integerLiteral : HexInteger
| DecimalInteger
;
-HexInteger : L_0X ( HexDigit )+ ;
+HexInteger : '0x' ( HexDigit )+ ;
DecimalInteger : ZeroDigit
| ( NonZeroDigit ( Digit )* )
@@ -493,7 +496,7 @@ WHITESPACE : SPACE
;
Comment : ( '/*' ( Comment_1 | ( '*' Comment_2 ) )* '*/' )
- | ( '//' Comment_3 CR? ( LF | EOF ) )
+ | ( '//' ( Comment_3 )* CR? ( LF | EOF ) )
;
leftArrowHead : '<'
@@ -524,8 +527,6 @@ dash : '-'
| '－'
;
-L_0X : ( '0' | '0' ) ( 'X' | 'x' ) ;
-
fragment FF : [\f] ;
fragment EscapedSymbolicName_0 : [\u0000-_a-\uFFFF] ;
diff --git a/src/storage/property_value.cpp b/src/storage/property_value.cpp
index be7ac014f..d00baa245 100644
--- a/src/storage/property_value.cpp
+++ b/src/storage/property_value.cpp
@@ -10,37 +10,42 @@
// Value extraction template instantiations
template <>
bool PropertyValue::Value<bool>() const {
- debug_assert(type_ == PropertyValue::Type::Bool,
- "Incompatible template param and type");
+ if (type_ != PropertyValue::Type::Bool) {
+ throw PropertyValueException("Incompatible template param and type");
+ }
return bool_v;
}
template <>
std::string PropertyValue::Value<std::string>() const {
- debug_assert(type_ == PropertyValue::Type::String,
- "Incompatible template param and type");
+ if (type_ != PropertyValue::Type::String) {
+ throw PropertyValueException("Incompatible template param and type");
+ }
return *string_v;
}
template <>
int PropertyValue::Value<int>() const {
- debug_assert(type_ == PropertyValue::Type::Int,
- "Incompatible template param and type");
+ if (type_ != PropertyValue::Type::Int) {
+ throw PropertyValueException("Incompatible template param and type");
+ }
return int_v;
}
template <>
double PropertyValue::Value<double>() const {
- debug_assert(type_ == PropertyValue::Type::Double,
- "Incompatible template param and type");
+ if (type_ != PropertyValue::Type::Double) {
+ throw PropertyValueException("Incompatible template param and type");
+ }
return double_v;
}
template <>
std::vector<PropertyValue> PropertyValue::Value<std::vector<PropertyValue>>()
const {
- debug_assert(type_ == PropertyValue::Type::List,
- "Incompatible template param and type");
+ if (type_ != PropertyValue::Type::List) {
+ throw PropertyValueException("Incompatible template param and type");
+ }
return *list_v;
}
diff --git a/tests/manual/antlr_tree_pretty_print.cpp b/tests/manual/antlr_tree_pretty_print.cpp
new file mode 100644
index 000000000..8dd5c4517
--- /dev/null
+++ b/tests/manual/antlr_tree_pretty_print.cpp
@@ -0,0 +1,62 @@
+#include <iostream>
+#include <istream>
+#include <iterator>
+#include <ostream>
+#include <string>
+
+#include "antlr4-runtime.h"
+#include "query/frontend/opencypher/generated/CypherLexer.h"
+#include "query/frontend/opencypher/generated/CypherParser.h"
+
+using namespace antlropencypher;
+using namespace antlr4;
+
+std::string ReadAllInput() {
+ // don't skip the whitespace while reading
+ std::cin >> std::noskipws;
+
+ // use stream iterators to copy the stream to a string
+ std::istream_iterator<char> it(std::cin);
+ std::istream_iterator<char> end;
+ std::string results(it, end);
+ return results;
+}
+
+int main(int, const char**) {
+ std::string input_string = ReadAllInput();
+ ANTLRInputStream input(input_string);
+ CypherLexer lexer(&input);
+ CommonTokenStream tokens(&lexer);
+
+ tokens.fill();
+ for (auto token : tokens.getTokens()) {
+ std::cout << token->toString() << std::endl;
+ }
+
+ CypherParser parser(&tokens);
+ tree::ParseTree* tree = parser.cypher();
+
+ // Print tree indented. This is a hacky implementation and not very correct.
+ std::string indent;
+ std::string string_tree = tree->toStringTree(&parser);
+ for (int i = 0; i < (int)string_tree.size(); ++i) {
+ char c = string_tree[i];
+ char next_c = i + 1 != (int)string_tree.size() ? string_tree[i + 1] : '\0';
+ char prev_c = i - 1 != (int)string_tree.size() ? string_tree[i - 1] : '\0';
+ if (c == '(' && next_c != ' ') {
+ indent.push_back(' ');
+ std::cout << "(";
+ } else if (c == ')' && prev_c != ' ') {
+ indent.pop_back();
+ std::cout << ")";
+ } else {
+ if (c == ' ' && prev_c != ' ') {
+ std::cout << "\n" << indent;
+ } else if (c != ' ') {
+ std::cout << c;
+ }
+ }
+ }
+ std::cout << std::endl;
+ return 0;
+}
diff --git a/tests/unit/cypher_main_visitor.cpp b/tests/unit/cypher_main_visitor.cpp
index b4bb88c14..f1b6682b3 100644
--- a/tests/unit/cypher_main_visitor.cpp
+++ b/tests/unit/cypher_main_visitor.cpp
@@ -13,6 +13,8 @@ using namespace ::testing;
namespace {
+using namespace backend::cpp;
+
class ParserTables {
template <typename T>
auto FilterAnies(std::unordered_map<std::string, antlrcpp::Any> map) {
@@ -31,7 +33,7 @@ class ParserTables {
auto *tree = parser.tree();
CypherMainVisitor visitor;
visitor.visit(tree);
- identifiers_map_ = visitor.identifiers_map();
+ identifiers_map_ = visitor.ids_map().back();
symbol_table_ = visitor.symbol_table();
pattern_parts_ = FilterAnies<PatternPart>(symbol_table_);
nodes_ = FilterAnies<Node>(symbol_table_);
@@ -51,7 +53,7 @@ void CompareNodes(std::pair<std::string, Node> node_entry,
std::vector<std::string> labels,
std::vector<std::string> property_keys) {
auto node = node_entry.second;
- ASSERT_EQ(node_entry.first, node.output_identifier);
+ ASSERT_EQ(node_entry.first, node.output_id);
ASSERT_THAT(node.labels,
UnorderedElementsAreArray(labels.begin(), labels.end()));
std::vector<std::string> node_property_keys;
@@ -72,7 +74,7 @@ void CompareRelationships(
std::vector<std::string> property_keys, bool has_range,
int64_t lower_bound = 1LL, int64_t upper_bound = LLONG_MAX) {
auto relationship = relationship_entry.second;
- ASSERT_EQ(relationship_entry.first, relationship.output_identifier);
+ ASSERT_EQ(relationship_entry.first, relationship.output_id);
ASSERT_EQ(relationship.direction, direction);
ASSERT_THAT(relationship.types,
UnorderedElementsAreArray(types.begin(), types.end()));
@@ -299,6 +301,55 @@ TEST(CompilerStructuresTest, PatternPartVariable) {
ASSERT_NE(parser.pattern_parts_.find(output_identifier),
parser.pattern_parts_.end());
}
+
+// Multiple nodes with same variable and properties.
+TEST(CompilerStructuresTest, MultipleNodesWithVariableAndProperties) {
+ ASSERT_THROW(ParserTables parser("CREATE (a {b: 5})-[]-(a {c: 5})"),
+ SemanticException);
+}
+
+// Multiple nodes with same variable name.
+TEST(CompilerStructuresTest, MultipleNodesWithVariable) {
+ ParserTables parser("CREATE (a {b: 5, c: 5})-[]-(a)");
+ ASSERT_EQ(parser.identifiers_map_.size(), 1U);
+ ASSERT_EQ(parser.pattern_parts_.size(), 1U);
+ ASSERT_EQ(parser.relationships_.size(), 1U);
+ ASSERT_EQ(parser.nodes_.size(), 1U);
+ auto pattern_part = parser.pattern_parts_.begin()->second;
+ ASSERT_EQ(pattern_part.nodes.size(), 2U);
+ ASSERT_EQ(pattern_part.relationships.size(), 1U);
+ ASSERT_EQ(pattern_part.nodes[0], pattern_part.nodes[1]);
+}
+
+// Multiple relationships with same variable name and properties.
+TEST(CompilerStructuresTest, MultipleRelationshipsWithVariableAndProperties) {
+ ASSERT_THROW(ParserTables parser("CREATE ()-[e {a: 5}]-()-[e {c: 5}]-()"),
+ SemanticException);
+}
+
+// Multiple relationships with same variable name.
+TEST(CompilerStructuresTest, MultipleRelationshipsWithVariable) {
+ ParserTables parser("CREATE ()-[a {a: 5}]-()-[a]-()");
+ ASSERT_EQ(parser.identifiers_map_.size(), 1U);
+ ASSERT_EQ(parser.pattern_parts_.size(), 1U);
+ ASSERT_EQ(parser.relationships_.size(), 1U);
+ ASSERT_EQ(parser.nodes_.size(), 3U);
+ auto pattern_part = parser.pattern_parts_.begin()->second;
+ ASSERT_EQ(pattern_part.nodes.size(), 3U);
+ ASSERT_EQ(pattern_part.relationships.size(), 2U);
+ ASSERT_NE(pattern_part.nodes[0], pattern_part.nodes[1]);
+ ASSERT_NE(pattern_part.nodes[1], pattern_part.nodes[2]);
+ ASSERT_NE(pattern_part.nodes[0], pattern_part.nodes[2]);
+ ASSERT_EQ(pattern_part.relationships[0], pattern_part.relationships[1]);
+}
+
+// Different structures (nodes, realtionships, patterns) with same variable
+// name.
+TEST(CompilerStructuresTest, DifferentTypesWithVariable) {
+ ASSERT_THROW(ParserTables parser("CREATE a=(a)"), SemanticException);
+ ASSERT_THROW(ParserTables parser("CREATE (a)-[a]-()"), SemanticException);
+ ASSERT_THROW(ParserTables parser("CREATE a=()-[a]-()"), SemanticException);
+}
}
int main(int argc, char **argv) {
diff --git a/tests/unit/typed_value.cpp b/tests/unit/typed_value.cpp
index 495cbe29d..f9ebfaa14 100644
--- a/tests/unit/typed_value.cpp
+++ b/tests/unit/typed_value.cpp
@@ -210,7 +210,6 @@ TEST(TypedValue, Sum) {
std::vector<TypedValue> out3 = {1, 2, true, "a", 1, 2, true, "a"};
EXPECT_PROP_EQ(
(TypedValue(2) + TypedValue(in)).Value<std::vector<TypedValue>>(), out1);
- std::cerr << (TypedValue(2) + TypedValue(in)) << "\n";
EXPECT_PROP_EQ(
(TypedValue(in) + TypedValue(2)).Value<std::vector<TypedValue>>(), out2);
EXPECT_PROP_EQ(
@@ -322,3 +321,13 @@ TEST(TypedValue, LogicalOr) {
EXPECT_PROP_EQ(TypedValue(true) || TypedValue(true), TypedValue(true));
EXPECT_PROP_EQ(TypedValue(false) || TypedValue(true), TypedValue(true));
}
+
+TEST(TypedValue, LogicalXor) {
+ TestLogicalThrows(
+ [](const TypedValue& p1, const TypedValue& p2) { return p1 ^ p2; });
+ EXPECT_PROP_ISNULL(TypedValue::Null && TypedValue(true));
+ EXPECT_PROP_EQ(TypedValue(true) ^ TypedValue(true), TypedValue(false));
+ EXPECT_PROP_EQ(TypedValue(false) ^ TypedValue(true), TypedValue(true));
+ EXPECT_PROP_EQ(TypedValue(true) ^ TypedValue(false), TypedValue(true));
+ EXPECT_PROP_EQ(TypedValue(false) ^ TypedValue(false), TypedValue(false));
+}