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 +#include + +#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 +#include +#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 labels; - std::unordered_map - properties; + std::unordered_map properties; }; struct Relationship { enum Direction { LEFT, RIGHT, BOTH }; - std::string output_identifier; + std::string output_id; Direction direction = Direction::BOTH; std::vector types; - std::unordered_map - properties; + std::unordered_map 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 nodes; - std::vector relationships; + std::string output_id; + std::vector nodes; + std::vector 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 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 #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 MapTokensToOperators( + antlr4::ParserRuleContext *node, + const std::unordered_map token_to_operator) { + std::vector 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 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()] = - node.output_identifier; + auto variable = ctx->variable()->accept(this).as(); + 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()) { + throw SemanticException(); + } + new_node = false; + node = symbol_table_[curr_id_map[variable]].as(); + } 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>(); } if (ctx->properties()) { - node.properties = - ctx->properties() - ->accept(this) - .as>(); + node.properties = ctx->properties() + ->accept(this) + .as>(); } - 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 map; + std::unordered_map map; for (int i = 0; i < (int)ctx->propertyKeyName().size(); ++i) { map[ctx->propertyKeyName()[i]->accept(this).as()] = - ctx->expression()[i]; + ctx->expression()[i]->accept(this).as(); } 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 pattern; + std::vector pattern; for (auto *pattern_part : ctx->patternPart()) { - pattern.push_back(pattern_part->accept(this).as()); + pattern.push_back(pattern_part->accept(this).as()); } return pattern; } @@ -95,11 +136,15 @@ antlrcpp::Any CypherMainVisitor::visitPatternPart( PatternPart pattern_part = ctx->anonymousPatternPart()->accept(this).as(); if (ctx->variable()) { - identifiers_map_[ctx->variable()->accept(this).as()] = - pattern_part.output_identifier; + std::string variable = ctx->variable()->accept(this).as(); + 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()); + pattern_part.output_id = new_id(); + pattern_part.nodes.push_back( + ctx->nodePattern()->accept(this).as()); for (auto *pattern_element_chain : ctx->patternElementChain()) { - auto element = - pattern_element_chain->accept(this).as>(); + auto element = pattern_element_chain->accept(this) + .as>(); 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( - ctx->relationshipPattern()->accept(this).as(), - ctx->nodePattern()->accept(this).as()); + return std::pair( + ctx->relationshipPattern()->accept(this).as(), + ctx->nodePattern()->accept(this).as()); } 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(); + 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()) { + throw SemanticException(); + } + new_relationship = false; + relationship = symbol_table_[curr_id_map[variable]].as(); + } 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>(); + } + if (ctx->relationshipDetail()->properties()) { + relationship.properties = + ctx->relationshipDetail() + ->properties() + ->accept(this) + .as>(); + } + if (ctx->relationshipDetail()->rangeLiteral()) { + relationship.has_range = true; + auto range = ctx->relationshipDetail() + ->rangeLiteral() + ->accept(this) + .as>(); + 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()] = - relationship.output_identifier; - } - if (ctx->relationshipTypes()) { - relationship.types = - ctx->relationshipTypes()->accept(this).as>(); - } - if (ctx->properties()) { - relationship.properties = - ctx->properties() - ->accept(this) - .as>(); - } - if (ctx->rangeLiteral()) { - relationship.has_range = true; - auto range = - ctx->rangeLiteral()->accept(this).as>(); - relationship.lower_bound = range.first; - relationship.upper_bound = range.second; - } -} - antlrcpp::Any CypherMainVisitor::visitRelationshipTypes( CypherParser::RelationshipTypesContext *ctx) { std::vector 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(); + 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 children_ids; + children_ids.push_back(ctx->expression7()->accept(this).as()); + auto partial_comparison_expressions = ctx->partialComparisonExpression(); + for (auto *child : partial_comparison_expressions) { + children_ids.push_back(child->accept(this).as()); + } + + // Make all comparisons. + std::string first_operand = children_ids[0]; + std::vector 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(); + 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(); + 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(); + 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 + antlrcpp::Any LeftAssociativeOperatorExpression( + std::vector children, std::vector ops) { + assert(children.size()); + std::vector children_ids; + + for (auto *child : children) { + children_ids.push_back(child->accept(this).template as()); + } + + 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 + antlrcpp::Any LeftAssociativeOperatorExpression( + std::vector children, Function op) { + return LeftAssociativeOperatorExpression( + children, std::vector((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 labels. - */ + * @return vector labels. + */ antlrcpp::Any visitNodeLabels(CypherParser::NodeLabelsContext *ctx) override; /** - * @return unordered_map properties. - */ + * @return unordered_map properties - property key to + * expression id. + */ antlrcpp::Any visitProperties(CypherParser::PropertiesContext *ctx) override; /** - * @return unordered_map map. - */ + * @return unordered_map 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 pattern. - */ + * @return vector 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 - */ + * @return pair - 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. - */ + * @return vector. + */ antlrcpp::Any visitRelationshipTypes( CypherParser::RelationshipTypesContext *ctx) override; /** - * @return int64_t. - */ - antlrcpp::Any visitIntegerLiteral( - CypherParser::IntegerLiteralContext *ctx) override; - - /** - * @return pair. - */ + * @return pair. + */ 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 &identifiers_map() const { - return identifiers_map_; - } - const std::unordered_map &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> ids_map_{1}; - // Mapping of identifiers (nodes, relationships, values, lists ...) from query - // code to identifier that is used in generated code; - std::unordered_map identifiers_map_; - - // Mapping of output (generated) code identifiers to appropriate parser + // Mapping of output (generated) code ids to appropriate parser // structure. std::unordered_map 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().PropsAt(key); + } else if (t.type() == TypedValue::Type::Edge) { + return t.Value().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(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(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 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. // Value extraction template instantiations template <> bool TypedValue::Value() 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() 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() 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() 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::Value>() 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 TypedValue::Value>() 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() 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() 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() 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(); case TypedValue::Type::Double: return value.Value(); - 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() < b.Value(); + } } // 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() < b.Value(); + } } -// 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>(); auto list2 = b.Value>(); @@ -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() == b.Value(); + } } 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() == b.Value(); + } } // 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() == b.Value(); + } } 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()); - 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()); case TypedValue::Type::Double: return fmt::format("{}", value.Value()); - // 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(); case TypedValue::Type::Double: return -a.Value(); - 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() + b.Value(); + } } 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() - b.Value(); + } } 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() / b.Value(); + } } 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() * b.Value(); + } } 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() % b.Value(); + } } 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() && b.Value(); - } 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() || b.Value(); - } 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(a.Value() ^ b.Value()); + } + } 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 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& CypherLexer::getRuleNames() const { return _ruleNames; @@ -30,13 +33,20 @@ const std::vector& CypherLexer::getTokenNames() const { return _tokenNames; } -dfa::Vocabulary& CypherLexer::getVocabulary() const { return _vocabulary; } +dfa::Vocabulary& CypherLexer::getVocabulary() const { + return _vocabulary; +} const std::vector 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 CypherLexer::_decisionToDFA; @@ -46,1331 +56,864 @@ atn::PredictionContextCache CypherLexer::_sharedContextCache; atn::ATN CypherLexer::_atn; std::vector CypherLexer::_serializedATN; -std::vector 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 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 CypherLexer::_modeNames = {"DEFAULT_MODE"}; +std::vector CypherLexer::_modeNames = { + "DEFAULT_MODE" +}; std::vector CypherLexer::_literalNames = { - "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", - "'?'", "']'", "':'", "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", - "'^'", "'=~'", "'<>'", "'!='", "'<'", "'>'", "'<='", "'>='", "'.'", - "'!'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", "'﹤'", "'＜'", "'⟩'", - "'〉'", "'﹥'", "'＞'", "'­'", "'‐'", "'‑'", "'‒'", "'–'", "'—'", - "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", - "", "", "", "", "", "", "", "'0'"}; + "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'", + "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='", + "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", + "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "'­'", "'‐'", "'‑'", "'‒'", + "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "", + "", "", "", "", "", "'0'" +}; -std::vector 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 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 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(""); - } else { + if (name.empty()) { + _tokenNames.push_back(""); + } 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 &CypherParser::getRuleNames() const { +const std::vector& 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(0); } @@ -42,80 +47,85 @@ std::vector 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(listener); - if (parserListener != nullptr) parserListener->enterCypher(this); + if (parserListener != nullptr) + parserListener->enterCypher(this); } void CypherParser::CypherContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::CypherContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitCypher(this); else return visitor->visitChildren(this); } -CypherParser::CypherContext *CypherParser::cypher() { - CypherContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::CypherContext* CypherParser::cypher() { + CypherContext *_localctx = _tracker.createInstance(_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()->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()->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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitStatement(this); else return visitor->visitChildren(this); } -CypherParser::StatementContext *CypherParser::statement() { - StatementContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::StatementContext* CypherParser::statement() { + StatementContext *_localctx = _tracker.createInstance(_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(0); } + size_t CypherParser::QueryContext::getRuleIndex() const { return CypherParser::RuleQuery; } void CypherParser::QueryContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterQuery(this); + if (parserListener != nullptr) + parserListener->enterQuery(this); } void CypherParser::QueryContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::QueryContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitQuery(this); else return visitor->visitChildren(this); } -CypherParser::QueryContext *CypherParser::query() { - QueryContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::QueryContext* CypherParser::query() { + QueryContext *_localctx = _tracker.createInstance(_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(0); } -std::vector -CypherParser::RegularQueryContext::cypherUnion() { +std::vector CypherParser::RegularQueryContext::cypherUnion() { return getRuleContexts(); } -CypherParser::CypherUnionContext * -CypherParser::RegularQueryContext::cypherUnion(size_t i) { +CypherParser::CypherUnionContext* CypherParser::RegularQueryContext::cypherUnion(size_t i) { return getRuleContext(i); } @@ -258,70 +270,71 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::RegularQueryContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRegularQuery(this); else return visitor->visitChildren(this); } -CypherParser::RegularQueryContext *CypherParser::regularQuery() { - RegularQueryContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::RegularQueryContext* CypherParser::regularQuery() { + RegularQueryContext *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, 5, - _ctx); + alt = getInterpreter()->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()->adaptivePredict(_input, - 5, _ctx); + alt = getInterpreter()->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::SingleQueryContext::clause() { +std::vector CypherParser::SingleQueryContext::clause() { return getRuleContexts(); } -CypherParser::ClauseContext *CypherParser::SingleQueryContext::clause( - size_t i) { +CypherParser::ClauseContext* CypherParser::SingleQueryContext::clause(size_t i) { return getRuleContext(i); } @@ -351,70 +361,71 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::SingleQueryContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSingleQuery(this); else return visitor->visitChildren(this); } -CypherParser::SingleQueryContext *CypherParser::singleQuery() { - SingleQueryContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::SingleQueryContext* CypherParser::singleQuery() { + SingleQueryContext *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, 7, - _ctx); + alt = getInterpreter()->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()->adaptivePredict(_input, - 7, _ctx); + alt = getInterpreter()->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 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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::CypherUnionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitCypherUnion(this); else return visitor->visitChildren(this); } -CypherParser::CypherUnionContext *CypherParser::cypherUnion() { - CypherUnionContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::CypherUnionContext* CypherParser::cypherUnion() { + CypherUnionContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 10, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(195); - match(CypherParser::UNION); - setState(196); + switch (getInterpreter()->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(0); } -CypherParser::UnwindContext *CypherParser::ClauseContext::unwind() { +CypherParser::UnwindContext* CypherParser::ClauseContext::unwind() { return getRuleContext(0); } -CypherParser::MergeContext *CypherParser::ClauseContext::merge() { +CypherParser::MergeContext* CypherParser::ClauseContext::merge() { return getRuleContext(0); } -CypherParser::CreateContext *CypherParser::ClauseContext::create() { +CypherParser::CreateContext* CypherParser::ClauseContext::create() { return getRuleContext(0); } -CypherParser::SetContext *CypherParser::ClauseContext::set() { +CypherParser::SetContext* CypherParser::ClauseContext::set() { return getRuleContext(0); } -CypherParser::CypherDeleteContext *CypherParser::ClauseContext::cypherDelete() { +CypherParser::CypherDeleteContext* CypherParser::ClauseContext::cypherDelete() { return getRuleContext(0); } -CypherParser::RemoveContext *CypherParser::ClauseContext::remove() { +CypherParser::RemoveContext* CypherParser::ClauseContext::remove() { return getRuleContext(0); } -CypherParser::WithContext *CypherParser::ClauseContext::with() { +CypherParser::WithContext* CypherParser::ClauseContext::with() { return getRuleContext(0); } -CypherParser::CypherReturnContext *CypherParser::ClauseContext::cypherReturn() { +CypherParser::CypherReturnContext* CypherParser::ClauseContext::cypherReturn() { return getRuleContext(0); } + size_t CypherParser::ClauseContext::getRuleIndex() const { return CypherParser::RuleClause; } void CypherParser::ClauseContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterClause(this); + if (parserListener != nullptr) + parserListener->enterClause(this); } void CypherParser::ClauseContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::ClauseContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitClause(this); else return visitor->visitChildren(this); } -CypherParser::ClauseContext *CypherParser::clause() { - ClauseContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::ClauseContext* CypherParser::clause() { + ClauseContext *_localctx = _tracker.createInstance(_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(0); } -tree::TerminalNode *CypherParser::CypherMatchContext::OPTIONAL() { +tree::TerminalNode* CypherParser::CypherMatchContext::OPTIONAL() { return getToken(CypherParser::OPTIONAL, 0); } @@ -711,90 +726,93 @@ std::vector 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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::CypherMatchContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitCypherMatch(this); else return visitor->visitChildren(this); } -CypherParser::CypherMatchContext *CypherParser::cypherMatch() { - CypherMatchContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::CypherMatchContext* CypherParser::cypherMatch() { + CypherMatchContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 15, _ctx)) { - case 1: { - setState(230); - _errHandler->sync(this); + switch (getInterpreter()->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(0); } @@ -822,71 +839,76 @@ std::vector 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(0); } + size_t CypherParser::UnwindContext::getRuleIndex() const { return CypherParser::RuleUnwind; } void CypherParser::UnwindContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterUnwind(this); + if (parserListener != nullptr) + parserListener->enterUnwind(this); } void CypherParser::UnwindContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::UnwindContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitUnwind(this); else return visitor->visitChildren(this); } -CypherParser::UnwindContext *CypherParser::unwind() { - UnwindContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::UnwindContext* CypherParser::unwind() { + UnwindContext *_localctx = _tracker.createInstance(_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(0); } @@ -914,82 +935,83 @@ std::vector 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::MergeContext::mergeAction() { +std::vector CypherParser::MergeContext::mergeAction() { return getRuleContexts(); } -CypherParser::MergeActionContext *CypherParser::MergeContext::mergeAction( - size_t i) { +CypherParser::MergeActionContext* CypherParser::MergeContext::mergeAction(size_t i) { return getRuleContext(i); } + size_t CypherParser::MergeContext::getRuleIndex() const { return CypherParser::RuleMerge; } void CypherParser::MergeContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterMerge(this); + if (parserListener != nullptr) + parserListener->enterMerge(this); } void CypherParser::MergeContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::MergeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitMerge(this); else return visitor->visitChildren(this); } -CypherParser::MergeContext *CypherParser::merge() { - MergeContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::MergeContext* CypherParser::merge() { + MergeContext *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, 18, - _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 18, _ctx); + alt = getInterpreter()->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 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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::MergeActionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitMergeAction(this); else return visitor->visitChildren(this); } -CypherParser::MergeActionContext *CypherParser::mergeAction() { - MergeActionContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::MergeActionContext* CypherParser::mergeAction() { + MergeActionContext *_localctx = _tracker.createInstance(_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()->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()->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(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(listener); - if (parserListener != nullptr) parserListener->enterCreate(this); + if (parserListener != nullptr) + parserListener->enterCreate(this); } void CypherParser::CreateContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::CreateContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitCreate(this); else return visitor->visitChildren(this); } -CypherParser::CreateContext *CypherParser::create() { - CreateContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::CreateContext* CypherParser::create() { + CreateContext *_localctx = _tracker.createInstance(_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::SetContext::setItem() { +std::vector CypherParser::SetContext::setItem() { return getRuleContexts(); } -CypherParser::SetItemContext *CypherParser::SetContext::setItem(size_t i) { +CypherParser::SetItemContext* CypherParser::SetContext::setItem(size_t i) { return getRuleContext(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(listener); - if (parserListener != nullptr) parserListener->enterSet(this); + if (parserListener != nullptr) + parserListener->enterSet(this); } void CypherParser::SetContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::SetContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSet(this); else return visitor->visitChildren(this); } -CypherParser::SetContext *CypherParser::set() { +CypherParser::SetContext* CypherParser::set() { SetContext *_localctx = _tracker.createInstance(_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(0); } -CypherParser::ExpressionContext *CypherParser::SetItemContext::expression() { +CypherParser::ExpressionContext* CypherParser::SetItemContext::expression() { return getRuleContext(0); } -CypherParser::VariableContext *CypherParser::SetItemContext::variable() { +std::vector 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(0); } -CypherParser::NodeLabelsContext *CypherParser::SetItemContext::nodeLabels() { +CypherParser::NodeLabelsContext* CypherParser::SetItemContext::nodeLabels() { return getRuleContext(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(listener); - if (parserListener != nullptr) parserListener->enterSetItem(this); + if (parserListener != nullptr) + parserListener->enterSetItem(this); } void CypherParser::SetItemContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::SetItemContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSetItem(this); else return visitor->visitChildren(this); } -CypherParser::SetItemContext *CypherParser::setItem() { - SetItemContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::SetItemContext* CypherParser::setItem() { + SetItemContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 22, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(284); - propertyExpression(); - setState(285); - match(CypherParser::T__2); - setState(286); - expression(); - break; - } + switch (getInterpreter()->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::CypherDeleteContext::expression() { +std::vector CypherParser::CypherDeleteContext::expression() { return getRuleContexts(); } -CypherParser::ExpressionContext *CypherParser::CypherDeleteContext::expression( - size_t i) { +CypherParser::ExpressionContext* CypherParser::CypherDeleteContext::expression(size_t i) { return getRuleContext(i); } -tree::TerminalNode *CypherParser::CypherDeleteContext::DETACH() { +tree::TerminalNode* CypherParser::CypherDeleteContext::DETACH() { return getToken(CypherParser::DETACH, 0); } @@ -1391,100 +1499,101 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::CypherDeleteContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitCypherDelete(this); else return visitor->visitChildren(this); } -CypherParser::CypherDeleteContext *CypherParser::cypherDelete() { - CypherDeleteContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::CypherDeleteContext* CypherParser::cypherDelete() { + CypherDeleteContext *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, 27, - _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 27, _ctx); + alt = getInterpreter()->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 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::RemoveContext::removeItem() { +std::vector CypherParser::RemoveContext::removeItem() { return getRuleContexts(); } -CypherParser::RemoveItemContext *CypherParser::RemoveContext::removeItem( - size_t i) { +CypherParser::RemoveItemContext* CypherParser::RemoveContext::removeItem(size_t i) { return getRuleContext(i); } + size_t CypherParser::RemoveContext::getRuleIndex() const { return CypherParser::RuleRemove; } void CypherParser::RemoveContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterRemove(this); + if (parserListener != nullptr) + parserListener->enterRemove(this); } void CypherParser::RemoveContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::RemoveContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRemove(this); else return visitor->visitChildren(this); } -CypherParser::RemoveContext *CypherParser::remove() { - RemoveContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::RemoveContext* CypherParser::remove() { + RemoveContext *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, 30, - _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 30, _ctx); + alt = getInterpreter()->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(0); } -CypherParser::NodeLabelsContext *CypherParser::RemoveItemContext::nodeLabels() { +CypherParser::NodeLabelsContext* CypherParser::RemoveItemContext::nodeLabels() { return getRuleContext(0); } -CypherParser::PropertyExpressionContext * -CypherParser::RemoveItemContext::propertyExpression() { +CypherParser::PropertyExpressionContext* CypherParser::RemoveItemContext::propertyExpression() { return getRuleContext(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(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(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(visitor)) + +antlrcpp::Any CypherParser::RemoveItemContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRemoveItem(this); else return visitor->visitChildren(this); } -CypherParser::RemoveItemContext *CypherParser::removeItem() { - RemoveItemContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::RemoveItemContext* CypherParser::removeItem() { + RemoveItemContext *_localctx = _tracker.createInstance(_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()->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()->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 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(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(0); } + size_t CypherParser::WithContext::getRuleIndex() const { return CypherParser::RuleWith; } void CypherParser::WithContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterWith(this); + if (parserListener != nullptr) + parserListener->enterWith(this); } void CypherParser::WithContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::WithContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitWith(this); else return visitor->visitChildren(this); } -CypherParser::WithContext *CypherParser::with() { - WithContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::WithContext* CypherParser::with() { + WithContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 33, _ctx)) { - case 1: { - setState(347); - _errHandler->sync(this); + switch (getInterpreter()->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()->adaptivePredict( - _input, 35, _ctx)) { - case 1: { - setState(355); - _errHandler->sync(this); + switch (getInterpreter()->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 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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::CypherReturnContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitCypherReturn(this); else return visitor->visitChildren(this); } -CypherParser::CypherReturnContext *CypherParser::cypherReturn() { - CypherReturnContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::CypherReturnContext* CypherParser::cypherReturn() { + CypherReturnContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 37, _ctx)) { - case 1: { - setState(362); - _errHandler->sync(this); + switch (getInterpreter()->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(0); } @@ -1911,97 +2024,100 @@ std::vector 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(0); } -CypherParser::SkipContext *CypherParser::ReturnBodyContext::skip() { +CypherParser::SkipContext* CypherParser::ReturnBodyContext::skip() { return getRuleContext(0); } -CypherParser::LimitContext *CypherParser::ReturnBodyContext::limit() { +CypherParser::LimitContext* CypherParser::ReturnBodyContext::limit() { return getRuleContext(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(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(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(visitor)) + +antlrcpp::Any CypherParser::ReturnBodyContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitReturnBody(this); else return visitor->visitChildren(this); } -CypherParser::ReturnBodyContext *CypherParser::returnBody() { - ReturnBodyContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::ReturnBodyContext* CypherParser::returnBody() { + ReturnBodyContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 38, _ctx)) { - case 1: { - setState(371); - match(CypherParser::SP); - setState(372); - order(); - break; - } + switch (getInterpreter()->adaptivePredict(_input, 46, _ctx)) { + case 1: { + setState(397); + match(CypherParser::SP); + setState(398); + order(); + break; } - setState(377); + + } + setState(403); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict( - _input, 39, _ctx)) { - case 1: { - setState(375); - match(CypherParser::SP); - setState(376); - skip(); - break; - } + switch (getInterpreter()->adaptivePredict(_input, 47, _ctx)) { + case 1: { + setState(401); + match(CypherParser::SP); + setState(402); + skip(); + break; } - setState(381); + + } + setState(407); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict( - _input, 40, _ctx)) { - case 1: { - setState(379); - match(CypherParser::SP); - setState(380); - limit(); - break; - } + switch (getInterpreter()->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::ReturnItemsContext::returnItem() { +std::vector CypherParser::ReturnItemsContext::returnItem() { return getRuleContexts(); } -CypherParser::ReturnItemContext *CypherParser::ReturnItemsContext::returnItem( - size_t i) { +CypherParser::ReturnItemContext* CypherParser::ReturnItemsContext::returnItem(size_t i) { return getRuleContext(i); } @@ -2031,91 +2144,91 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::ReturnItemsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitReturnItems(this); else return visitor->visitChildren(this); } -CypherParser::ReturnItemsContext *CypherParser::returnItems() { - ReturnItemsContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::ReturnItemsContext* CypherParser::returnItems() { + ReturnItemsContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 43, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 43, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 46, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 46, _ctx); + alt = getInterpreter()->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(0); } @@ -2234,77 +2345,80 @@ std::vector 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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::ReturnItemContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitReturnItem(this); else return visitor->visitChildren(this); } -CypherParser::ReturnItemContext *CypherParser::returnItem() { - ReturnItemContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::ReturnItemContext* CypherParser::returnItem() { + ReturnItemContext *_localctx = _tracker.createInstance(_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()->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()->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 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::OrderContext::sortItem() { +std::vector CypherParser::OrderContext::sortItem() { return getRuleContexts(); } -CypherParser::SortItemContext *CypherParser::OrderContext::sortItem(size_t i) { +CypherParser::SortItemContext* CypherParser::OrderContext::sortItem(size_t i) { return getRuleContext(i); } + size_t CypherParser::OrderContext::getRuleIndex() const { return CypherParser::RuleOrder; } void CypherParser::OrderContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterOrder(this); + if (parserListener != nullptr) + parserListener->enterOrder(this); } void CypherParser::OrderContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::OrderContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitOrder(this); else return visitor->visitChildren(this); } -CypherParser::OrderContext *CypherParser::order() { - OrderContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::OrderContext* CypherParser::order() { + OrderContext *_localctx = _tracker.createInstance(_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(0); } + size_t CypherParser::SkipContext::getRuleIndex() const { return CypherParser::RuleSkip; } void CypherParser::SkipContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterSkip(this); + if (parserListener != nullptr) + parserListener->enterSkip(this); } void CypherParser::SkipContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::SkipContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSkip(this); else return visitor->visitChildren(this); } -CypherParser::SkipContext *CypherParser::skip() { - SkipContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::SkipContext* CypherParser::skip() { + SkipContext *_localctx = _tracker.createInstance(_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(0); } + size_t CypherParser::LimitContext::getRuleIndex() const { return CypherParser::RuleLimit; } void CypherParser::LimitContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterLimit(this); + if (parserListener != nullptr) + parserListener->enterLimit(this); } void CypherParser::LimitContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::LimitContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitLimit(this); else return visitor->visitChildren(this); } -CypherParser::LimitContext *CypherParser::limit() { - LimitContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::LimitContext* CypherParser::limit() { + LimitContext *_localctx = _tracker.createInstance(_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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::SortItemContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSortItem(this); else return visitor->visitChildren(this); } -CypherParser::SortItemContext *CypherParser::sortItem() { - SortItemContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::SortItemContext* CypherParser::sortItem() { + SortItemContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 52, _ctx)) { - case 1: { - setState(447); - _errHandler->sync(this); + switch (getInterpreter()->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(0); } + size_t CypherParser::WhereContext::getRuleIndex() const { return CypherParser::RuleWhere; } void CypherParser::WhereContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterWhere(this); + if (parserListener != nullptr) + parserListener->enterWhere(this); } void CypherParser::WhereContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::WhereContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitWhere(this); else return visitor->visitChildren(this); } -CypherParser::WhereContext *CypherParser::where() { - WhereContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::WhereContext* CypherParser::where() { + WhereContext *_localctx = _tracker.createInstance(_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::PatternContext::patternPart() { +std::vector CypherParser::PatternContext::patternPart() { return getRuleContexts(); } -CypherParser::PatternPartContext *CypherParser::PatternContext::patternPart( - size_t i) { +CypherParser::PatternPartContext* CypherParser::PatternContext::patternPart(size_t i) { return getRuleContext(i); } @@ -2738,79 +2866,81 @@ std::vector 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(listener); - if (parserListener != nullptr) parserListener->enterPattern(this); + if (parserListener != nullptr) + parserListener->enterPattern(this); } void CypherParser::PatternContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::PatternContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPattern(this); else return visitor->visitChildren(this); } -CypherParser::PatternContext *CypherParser::pattern() { - PatternContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::PatternContext* CypherParser::pattern() { + PatternContext *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, 55, - _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 55, _ctx); + alt = getInterpreter()->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(0); } -CypherParser::AnonymousPatternPartContext * -CypherParser::PatternPartContext::anonymousPatternPart() { +CypherParser::AnonymousPatternPartContext* CypherParser::PatternPartContext::anonymousPatternPart() { return getRuleContext(0); } @@ -2839,43 +2967,45 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::PatternPartContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPatternPart(this); else return visitor->visitChildren(this); } -CypherParser::PatternPartContext *CypherParser::patternPart() { - PatternPartContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::PatternPartContext* CypherParser::patternPart() { + PatternPartContext *_localctx = _tracker.createInstance(_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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::AnonymousPatternPartContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitAnonymousPatternPart(this); else return visitor->visitChildren(this); } -CypherParser::AnonymousPatternPartContext * -CypherParser::anonymousPatternPart() { - AnonymousPatternPartContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::AnonymousPatternPartContext* CypherParser::anonymousPatternPart() { + AnonymousPatternPartContext *_localctx = _tracker.createInstance(_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(0); } -std::vector -CypherParser::PatternElementContext::patternElementChain() { +std::vector CypherParser::PatternElementContext::patternElementChain() { return getRuleContexts(); } -CypherParser::PatternElementChainContext * -CypherParser::PatternElementContext::patternElementChain(size_t i) { +CypherParser::PatternElementChainContext* CypherParser::PatternElementContext::patternElementChain(size_t i) { return getRuleContext(i); } @@ -3054,94 +3180,94 @@ std::vector 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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::PatternElementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPatternElement(this); else return visitor->visitChildren(this); } -CypherParser::PatternElementContext *CypherParser::patternElement() { - PatternElementContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::PatternElementContext* CypherParser::patternElement() { + PatternElementContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 61, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(485); - nodePattern(); - setState(492); - _errHandler->sync(this); - alt = getInterpreter()->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()->adaptivePredict(_input, 69, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(511); + nodePattern(); + setState(518); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 68, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(513); _errHandler->sync(this); - alt = getInterpreter()->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()->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 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(0); } -CypherParser::NodeLabelsContext * -CypherParser::NodePatternContext::nodeLabels() { +CypherParser::NodeLabelsContext* CypherParser::NodePatternContext::nodeLabels() { return getRuleContext(0); } -CypherParser::PropertiesContext * -CypherParser::NodePatternContext::properties() { +CypherParser::PropertiesContext* CypherParser::NodePatternContext::properties() { return getRuleContext(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(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(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(visitor)) + +antlrcpp::Any CypherParser::NodePatternContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitNodePattern(this); else return visitor->visitChildren(this); } -CypherParser::NodePatternContext *CypherParser::nodePattern() { - NodePatternContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::NodePatternContext* CypherParser::nodePattern() { + NodePatternContext *_localctx = _tracker.createInstance(_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(0); } -CypherParser::NodePatternContext * -CypherParser::PatternElementChainContext::nodePattern() { +CypherParser::NodePatternContext* CypherParser::PatternElementChainContext::nodePattern() { return getRuleContext(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(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(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(visitor)) + +antlrcpp::Any CypherParser::PatternElementChainContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPatternElementChain(this); else return visitor->visitChildren(this); } -CypherParser::PatternElementChainContext *CypherParser::patternElementChain() { - PatternElementChainContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::PatternElementChainContext* CypherParser::patternElementChain() { + PatternElementChainContext *_localctx = _tracker.createInstance(_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(0); } -std::vector -CypherParser::RelationshipPatternContext::dash() { +std::vector CypherParser::RelationshipPatternContext::dash() { return getRuleContexts(); } -CypherParser::DashContext *CypherParser::RelationshipPatternContext::dash( - size_t i) { +CypherParser::DashContext* CypherParser::RelationshipPatternContext::dash(size_t i) { return getRuleContext(i); } -CypherParser::RightArrowHeadContext * -CypherParser::RelationshipPatternContext::rightArrowHead() { +CypherParser::RightArrowHeadContext* CypherParser::RelationshipPatternContext::rightArrowHead() { return getRuleContext(0); } -std::vector -CypherParser::RelationshipPatternContext::SP() { +std::vector 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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::RelationshipPatternContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRelationshipPattern(this); else return visitor->visitChildren(this); } -CypherParser::RelationshipPatternContext *CypherParser::relationshipPattern() { - RelationshipPatternContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::RelationshipPatternContext* CypherParser::relationshipPattern() { + RelationshipPatternContext *_localctx = _tracker.createInstance(_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()->adaptivePredict( - _input, 86, _ctx)) { + switch (getInterpreter()->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()->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()->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()->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()->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()->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()->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()->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()->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 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(0); } -CypherParser::RelationshipTypesContext * -CypherParser::RelationshipDetailContext::relationshipTypes() { +CypherParser::RelationshipTypesContext* CypherParser::RelationshipDetailContext::relationshipTypes() { return getRuleContext(0); } -CypherParser::RangeLiteralContext * -CypherParser::RelationshipDetailContext::rangeLiteral() { +CypherParser::RangeLiteralContext* CypherParser::RelationshipDetailContext::rangeLiteral() { return getRuleContext(0); } -CypherParser::PropertiesContext * -CypherParser::RelationshipDetailContext::properties() { +CypherParser::PropertiesContext* CypherParser::RelationshipDetailContext::properties() { return getRuleContext(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(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(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(visitor)) + +antlrcpp::Any CypherParser::RelationshipDetailContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRelationshipDetail(this); else return visitor->visitChildren(this); } -CypherParser::RelationshipDetailContext *CypherParser::relationshipDetail() { - RelationshipDetailContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::RelationshipDetailContext* CypherParser::relationshipDetail() { + RelationshipDetailContext *_localctx = _tracker.createInstance(_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(0); -} - -CypherParser::ParameterContext *CypherParser::PropertiesContext::parameter() { - return getRuleContext(0); -} - -size_t CypherParser::PropertiesContext::getRuleIndex() const { - return CypherParser::RuleProperties; -} - -void CypherParser::PropertiesContext::enterRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterProperties(this); -} - -void CypherParser::PropertiesContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitProperties(this); -} - -antlrcpp::Any CypherParser::PropertiesContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitProperties(this); - else - return visitor->visitChildren(this); -} - -CypherParser::PropertiesContext *CypherParser::properties() { - PropertiesContext *_localctx = - _tracker.createInstance(_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::RelationshipTypesContext::relTypeName() { - return getRuleContexts(); -} - -CypherParser::RelTypeNameContext * -CypherParser::RelationshipTypesContext::relTypeName(size_t i) { - return getRuleContext(i); -} - -std::vector 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(listener); - if (parserListener != nullptr) parserListener->enterRelationshipTypes(this); -} - -void CypherParser::RelationshipTypesContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitRelationshipTypes(this); -} - -antlrcpp::Any CypherParser::RelationshipTypesContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitRelationshipTypes(this); - else - return visitor->visitChildren(this); -} - -CypherParser::RelationshipTypesContext *CypherParser::relationshipTypes() { - RelationshipTypesContext *_localctx = - _tracker.createInstance(_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::NodeLabelsContext::nodeLabel() { +CypherParser::MapLiteralContext* CypherParser::PropertiesContext::mapLiteral() { + return getRuleContext(0); +} + +CypherParser::ParameterContext* CypherParser::PropertiesContext::parameter() { + return getRuleContext(0); +} + + +size_t CypherParser::PropertiesContext::getRuleIndex() const { + return CypherParser::RuleProperties; +} + +void CypherParser::PropertiesContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterProperties(this); +} + +void CypherParser::PropertiesContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitProperties(this); +} + + +antlrcpp::Any CypherParser::PropertiesContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitProperties(this); + else + return visitor->visitChildren(this); +} + +CypherParser::PropertiesContext* CypherParser::properties() { + PropertiesContext *_localctx = _tracker.createInstance(_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::RelationshipTypesContext::relTypeName() { + return getRuleContexts(); +} + +CypherParser::RelTypeNameContext* CypherParser::RelationshipTypesContext::relTypeName(size_t i) { + return getRuleContext(i); +} + +std::vector 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(listener); + if (parserListener != nullptr) + parserListener->enterRelationshipTypes(this); +} + +void CypherParser::RelationshipTypesContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitRelationshipTypes(this); +} + + +antlrcpp::Any CypherParser::RelationshipTypesContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitRelationshipTypes(this); + else + return visitor->visitChildren(this); +} + +CypherParser::RelationshipTypesContext* CypherParser::relationshipTypes() { + RelationshipTypesContext *_localctx = _tracker.createInstance(_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()->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()->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::NodeLabelsContext::nodeLabel() { return getRuleContexts(); } -CypherParser::NodeLabelContext *CypherParser::NodeLabelsContext::nodeLabel( - size_t i) { +CypherParser::NodeLabelContext* CypherParser::NodeLabelsContext::nodeLabel(size_t i) { return getRuleContext(i); } @@ -4046,70 +4206,71 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::NodeLabelsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitNodeLabels(this); else return visitor->visitChildren(this); } -CypherParser::NodeLabelsContext *CypherParser::nodeLabels() { - NodeLabelsContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::NodeLabelsContext* CypherParser::nodeLabels() { + NodeLabelsContext *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, 98, - _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 98, _ctx); + alt = getInterpreter()->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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::NodeLabelContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitNodeLabel(this); else return visitor->visitChildren(this); } -CypherParser::NodeLabelContext *CypherParser::nodeLabel() { - NodeLabelContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::NodeLabelContext* CypherParser::nodeLabel() { + NodeLabelContext *_localctx = _tracker.createInstance(_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 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::RangeLiteralContext::integerLiteral() { +std::vector CypherParser::RangeLiteralContext::integerLiteral() { return getRuleContexts(); } -CypherParser::IntegerLiteralContext * -CypherParser::RangeLiteralContext::integerLiteral(size_t i) { +CypherParser::IntegerLiteralContext* CypherParser::RangeLiteralContext::integerLiteral(size_t i) { return getRuleContext(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(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(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(visitor)) + +antlrcpp::Any CypherParser::RangeLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRangeLiteral(this); else return visitor->visitChildren(this); } -CypherParser::RangeLiteralContext *CypherParser::rangeLiteral() { - RangeLiteralContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::RangeLiteralContext* CypherParser::rangeLiteral() { + RangeLiteralContext *_localctx = _tracker.createInstance(_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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::LabelNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitLabelName(this); else return visitor->visitChildren(this); } -CypherParser::LabelNameContext *CypherParser::labelName() { - LabelNameContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::LabelNameContext* CypherParser::labelName() { + LabelNameContext *_localctx = _tracker.createInstance(_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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::RelTypeNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRelTypeName(this); else return visitor->visitChildren(this); } -CypherParser::RelTypeNameContext *CypherParser::relTypeName() { - RelTypeNameContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::RelTypeNameContext* CypherParser::relTypeName() { + RelTypeNameContext *_localctx = _tracker.createInstance(_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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression(this); else return visitor->visitChildren(this); } -CypherParser::ExpressionContext *CypherParser::expression() { - ExpressionContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::ExpressionContext* CypherParser::expression() { + ExpressionContext *_localctx = _tracker.createInstance(_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::Expression12Context::expression11() { +std::vector CypherParser::Expression12Context::expression11() { return getRuleContexts(); } -CypherParser::Expression11Context * -CypherParser::Expression12Context::expression11(size_t i) { +CypherParser::Expression11Context* CypherParser::Expression12Context::expression11(size_t i) { return getRuleContext(i); } @@ -4496,7 +4672,7 @@ std::vector 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 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression12Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression12(this); else return visitor->visitChildren(this); } -CypherParser::Expression12Context *CypherParser::expression12() { - Expression12Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression12Context* CypherParser::expression12() { + Expression12Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 106, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 106, _ctx); + alt = getInterpreter()->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::Expression11Context::expression10() { +std::vector CypherParser::Expression11Context::expression10() { return getRuleContexts(); } -CypherParser::Expression10Context * -CypherParser::Expression11Context::expression10(size_t i) { +CypherParser::Expression10Context* CypherParser::Expression11Context::expression10(size_t i) { return getRuleContext(i); } @@ -4594,7 +4768,7 @@ std::vector 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 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression11Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression11(this); else return visitor->visitChildren(this); } -CypherParser::Expression11Context *CypherParser::expression11() { - Expression11Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression11Context* CypherParser::expression11() { + Expression11Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 107, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 107, _ctx); + alt = getInterpreter()->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::Expression10Context::expression9() { +std::vector CypherParser::Expression10Context::expression9() { return getRuleContexts(); } -CypherParser::Expression9Context * -CypherParser::Expression10Context::expression9(size_t i) { +CypherParser::Expression9Context* CypherParser::Expression10Context::expression9(size_t i) { return getRuleContext(i); } @@ -4692,7 +4864,7 @@ std::vector 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 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression10Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression10(this); else return visitor->visitChildren(this); } -CypherParser::Expression10Context *CypherParser::expression10() { - Expression10Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression10Context* CypherParser::expression10() { + Expression10Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 108, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 108, _ctx); + alt = getInterpreter()->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(0); } @@ -4785,7 +4956,7 @@ std::vector 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 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression9Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression9(this); else return visitor->visitChildren(this); } -CypherParser::Expression9Context *CypherParser::expression9() { - Expression9Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression9Context* CypherParser::expression9() { + Expression9Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 110, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 110, _ctx); + alt = getInterpreter()->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(0); } -std::vector -CypherParser::Expression8Context::partialComparisonExpression() { +std::vector CypherParser::Expression8Context::partialComparisonExpression() { return getRuleContexts(); } -CypherParser::PartialComparisonExpressionContext * -CypherParser::Expression8Context::partialComparisonExpression(size_t i) { +CypherParser::PartialComparisonExpressionContext* CypherParser::Expression8Context::partialComparisonExpression(size_t i) { return getRuleContext(i); } @@ -4891,70 +5059,71 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression8Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression8(this); else return visitor->visitChildren(this); } -CypherParser::Expression8Context *CypherParser::expression8() { - Expression8Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression8Context* CypherParser::expression8() { + Expression8Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 112, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 112, _ctx); + alt = getInterpreter()->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::Expression7Context::expression6() { +std::vector CypherParser::Expression7Context::expression6() { return getRuleContexts(); } -CypherParser::Expression6Context *CypherParser::Expression7Context::expression6( - size_t i) { +CypherParser::Expression6Context* CypherParser::Expression7Context::expression6(size_t i) { return getRuleContext(i); } @@ -4984,112 +5150,113 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression7Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression7(this); else return visitor->visitChildren(this); } -CypherParser::Expression7Context *CypherParser::expression7() { - Expression7Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression7Context* CypherParser::expression7() { + Expression7Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 118, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 117, _ctx)) { - case 1: { - setState(731); - _errHandler->sync(this); + switch (getInterpreter()->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()->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()->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::Expression6Context::expression5() { +std::vector CypherParser::Expression6Context::expression5() { return getRuleContexts(); } -CypherParser::Expression5Context *CypherParser::Expression6Context::expression5( - size_t i) { +CypherParser::Expression5Context* CypherParser::Expression6Context::expression5(size_t i) { return getRuleContext(i); } @@ -5119,136 +5283,137 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression6Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression6(this); else return visitor->visitChildren(this); } -CypherParser::Expression6Context *CypherParser::expression6() { - Expression6Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression6Context* CypherParser::expression6() { + Expression6Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 126, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 125, _ctx)) { - case 1: { - setState(753); - _errHandler->sync(this); + switch (getInterpreter()->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()->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()->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::Expression5Context::expression4() { +std::vector CypherParser::Expression5Context::expression4() { return getRuleContexts(); } -CypherParser::Expression4Context *CypherParser::Expression5Context::expression4( - size_t i) { +CypherParser::Expression4Context* CypherParser::Expression5Context::expression4(size_t i) { return getRuleContext(i); } @@ -5278,80 +5440,81 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression5Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression5(this); else return visitor->visitChildren(this); } -CypherParser::Expression5Context *CypherParser::expression5() { - Expression5Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression5Context* CypherParser::expression5() { + Expression5Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 129, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 129, _ctx); + alt = getInterpreter()->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(0); } @@ -5376,75 +5537,79 @@ std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression4Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression4(this); else return visitor->visitChildren(this); } -CypherParser::Expression4Context *CypherParser::expression4() { - Expression4Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression4Context* CypherParser::expression4() { + Expression4Context *_localctx = _tracker.createInstance(_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::Expression3Context::expression2() { +std::vector CypherParser::Expression3Context::expression2() { return getRuleContexts(); } -CypherParser::Expression2Context *CypherParser::Expression3Context::expression2( - size_t i) { +CypherParser::Expression2Context* CypherParser::Expression3Context::expression2(size_t i) { return getRuleContext(i); } -std::vector -CypherParser::Expression3Context::expression() { +std::vector CypherParser::Expression3Context::expression() { return getRuleContexts(); } -CypherParser::ExpressionContext *CypherParser::Expression3Context::expression( - size_t i) { +CypherParser::ExpressionContext* CypherParser::Expression3Context::expression(size_t i) { return getRuleContext(i); } @@ -5484,7 +5644,7 @@ std::vector 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 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 -CypherParser::Expression3Context::CYPHERNULL() { +std::vector 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 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 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 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 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 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 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression3Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression3(this); else return visitor->visitChildren(this); } -CypherParser::Expression3Context *CypherParser::expression3() { - Expression3Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression3Context* CypherParser::expression3() { + Expression3Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 140, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 139, _ctx)) { + switch (getInterpreter()->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()->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()->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()->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()->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(0); } -std::vector -CypherParser::Expression2Context::propertyLookup() { +std::vector CypherParser::Expression2Context::propertyLookup() { return getRuleContexts(); } -CypherParser::PropertyLookupContext * -CypherParser::Expression2Context::propertyLookup(size_t i) { +CypherParser::PropertyLookupContext* CypherParser::Expression2Context::propertyLookup(size_t i) { return getRuleContext(i); } -std::vector -CypherParser::Expression2Context::nodeLabels() { +std::vector CypherParser::Expression2Context::nodeLabels() { return getRuleContexts(); } -CypherParser::NodeLabelsContext *CypherParser::Expression2Context::nodeLabels( - size_t i) { +CypherParser::NodeLabelsContext* CypherParser::Expression2Context::nodeLabels(size_t i) { return getRuleContext(i); } +std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::Expression2Context::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitExpression2(this); else return visitor->visitChildren(this); } -CypherParser::Expression2Context *CypherParser::expression2() { - Expression2Context *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::Expression2Context* CypherParser::expression2() { + Expression2Context *_localctx = _tracker.createInstance(_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()->adaptivePredict(_input, - 142, _ctx); + alt = getInterpreter()->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()->adaptivePredict( - _input, 142, _ctx); + alt = getInterpreter()->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(0); } -CypherParser::ParameterContext *CypherParser::AtomContext::parameter() { +CypherParser::ParameterContext* CypherParser::AtomContext::parameter() { return getRuleContext(0); } -tree::TerminalNode *CypherParser::AtomContext::COUNT() { +tree::TerminalNode* CypherParser::AtomContext::COUNT() { return getToken(CypherParser::COUNT, 0); } @@ -6017,432 +6184,443 @@ std::vector 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(0); } -tree::TerminalNode *CypherParser::AtomContext::FILTER() { +CypherParser::PatternComprehensionContext* CypherParser::AtomContext::patternComprehension() { + return getRuleContext(0); +} + +tree::TerminalNode* CypherParser::AtomContext::FILTER() { return getToken(CypherParser::FILTER, 0); } -CypherParser::FilterExpressionContext * -CypherParser::AtomContext::filterExpression() { +CypherParser::FilterExpressionContext* CypherParser::AtomContext::filterExpression() { return getRuleContext(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(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(0); } -CypherParser::ParenthesizedExpressionContext * -CypherParser::AtomContext::parenthesizedExpression() { +CypherParser::ParenthesizedExpressionContext* CypherParser::AtomContext::parenthesizedExpression() { return getRuleContext(0); } -CypherParser::FunctionInvocationContext * -CypherParser::AtomContext::functionInvocation() { +CypherParser::FunctionInvocationContext* CypherParser::AtomContext::functionInvocation() { return getRuleContext(0); } -CypherParser::VariableContext *CypherParser::AtomContext::variable() { +CypherParser::VariableContext* CypherParser::AtomContext::variable() { return getRuleContext(0); } + size_t CypherParser::AtomContext::getRuleIndex() const { return CypherParser::RuleAtom; } void CypherParser::AtomContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterAtom(this); + if (parserListener != nullptr) + parserListener->enterAtom(this); } void CypherParser::AtomContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::AtomContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitAtom(this); else return visitor->visitChildren(this); } -CypherParser::AtomContext *CypherParser::atom() { - AtomContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::AtomContext* CypherParser::atom() { + AtomContext *_localctx = _tracker.createInstance(_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()->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()->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()->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()->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(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(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(0); } -CypherParser::ListLiteralContext *CypherParser::LiteralContext::listLiteral() { +CypherParser::ListLiteralContext* CypherParser::LiteralContext::listLiteral() { return getRuleContext(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(listener); - if (parserListener != nullptr) parserListener->enterLiteral(this); + if (parserListener != nullptr) + parserListener->enterLiteral(this); } void CypherParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitLiteral(this); else return visitor->visitChildren(this); } -CypherParser::LiteralContext *CypherParser::literal() { - LiteralContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::LiteralContext* CypherParser::literal() { + LiteralContext *_localctx = _tracker.createInstance(_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(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(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(visitor)) + +antlrcpp::Any CypherParser::BooleanLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitBooleanLiteral(this); else return visitor->visitChildren(this); } -CypherParser::BooleanLiteralContext *CypherParser::booleanLiteral() { - BooleanLiteralContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::BooleanLiteralContext* CypherParser::booleanLiteral() { + BooleanLiteralContext *_localctx = _tracker.createInstance(_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 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::ListLiteralContext::expression() { +std::vector CypherParser::ListLiteralContext::expression() { return getRuleContexts(); } -CypherParser::ExpressionContext *CypherParser::ListLiteralContext::expression( - size_t i) { +CypherParser::ExpressionContext* CypherParser::ListLiteralContext::expression(size_t i) { return getRuleContext(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(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(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(visitor)) + +antlrcpp::Any CypherParser::ListLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitListLiteral(this); else return visitor->visitChildren(this); } -CypherParser::ListLiteralContext *CypherParser::listLiteral() { - ListLiteralContext *_localctx = - _tracker.createInstance(_ctx, getState()); +CypherParser::ListLiteralContext* CypherParser::listLiteral() { + ListLiteralContext *_localctx = _tracker.createInstance(_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(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(listener); - if (parserListener != nullptr) - parserListener->enterPartialComparisonExpression(this); -} - -void CypherParser::PartialComparisonExpressionContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitPartialComparisonExpression(this); -} - -antlrcpp::Any CypherParser::PartialComparisonExpressionContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitPartialComparisonExpression(this); - else - return visitor->visitChildren(this); -} - -CypherParser::PartialComparisonExpressionContext * -CypherParser::partialComparisonExpression() { - PartialComparisonExpressionContext *_localctx = - _tracker.createInstance(_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(0); -} - -std::vector -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(listener); - if (parserListener != nullptr) - parserListener->enterParenthesizedExpression(this); -} - -void CypherParser::ParenthesizedExpressionContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitParenthesizedExpression(this); -} - -antlrcpp::Any CypherParser::ParenthesizedExpressionContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitParenthesizedExpression(this); - else - return visitor->visitChildren(this); -} - -CypherParser::ParenthesizedExpressionContext * -CypherParser::parenthesizedExpression() { - ParenthesizedExpressionContext *_localctx = - _tracker.createInstance(_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(0); -} - -std::vector -CypherParser::RelationshipsPatternContext::patternElementChain() { - return getRuleContexts(); -} - -CypherParser::PatternElementChainContext * -CypherParser::RelationshipsPatternContext::patternElementChain(size_t i) { - return getRuleContext(i); -} - -std::vector -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(listener); - if (parserListener != nullptr) - parserListener->enterRelationshipsPattern(this); -} - -void CypherParser::RelationshipsPatternContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitRelationshipsPattern(this); -} - -antlrcpp::Any CypherParser::RelationshipsPatternContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitRelationshipsPattern(this); - else - return visitor->visitChildren(this); -} - -CypherParser::RelationshipsPatternContext * -CypherParser::relationshipsPattern() { - RelationshipsPatternContext *_localctx = - _tracker.createInstance(_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()->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(0); -} - -CypherParser::WhereContext *CypherParser::FilterExpressionContext::where() { - return getRuleContext(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(listener); - if (parserListener != nullptr) parserListener->enterFilterExpression(this); -} - -void CypherParser::FilterExpressionContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitFilterExpression(this); -} - -antlrcpp::Any CypherParser::FilterExpressionContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitFilterExpression(this); - else - return visitor->visitChildren(this); -} - -CypherParser::FilterExpressionContext *CypherParser::filterExpression() { - FilterExpressionContext *_localctx = - _tracker.createInstance(_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()->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(0); +CypherParser::PartialComparisonExpressionContext::PartialComparisonExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { } -std::vector CypherParser::IdInCollContext::SP() { - return getTokens(CypherParser::SP); +CypherParser::Expression7Context* CypherParser::PartialComparisonExpressionContext::expression7() { + return getRuleContext(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(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(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(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(visitor)) - return parserVisitor->visitIdInColl(this); + +antlrcpp::Any CypherParser::PartialComparisonExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPartialComparisonExpression(this); else return visitor->visitChildren(this); } -CypherParser::IdInCollContext *CypherParser::idInColl() { - IdInCollContext *_localctx = - _tracker.createInstance(_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(0); -} - -std::vector -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::FunctionInvocationContext::expression() { - return getRuleContexts(); -} - -CypherParser::ExpressionContext * -CypherParser::FunctionInvocationContext::expression(size_t i) { - return getRuleContext(i); -} - -size_t CypherParser::FunctionInvocationContext::getRuleIndex() const { - return CypherParser::RuleFunctionInvocation; -} - -void CypherParser::FunctionInvocationContext::enterRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterFunctionInvocation(this); -} - -void CypherParser::FunctionInvocationContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitFunctionInvocation(this); -} - -antlrcpp::Any CypherParser::FunctionInvocationContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitFunctionInvocation(this); - else - return visitor->visitChildren(this); -} - -CypherParser::FunctionInvocationContext *CypherParser::functionInvocation() { - FunctionInvocationContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 126, CypherParser::RuleFunctionInvocation); +CypherParser::PartialComparisonExpressionContext* CypherParser::partialComparisonExpression() { + PartialComparisonExpressionContext *_localctx = _tracker.createInstance(_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()->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(listener); - if (parserListener != nullptr) parserListener->enterFunctionName(this); -} - -void CypherParser::FunctionNameContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitFunctionName(this); -} - -antlrcpp::Any CypherParser::FunctionNameContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitFunctionName(this); - else - return visitor->visitChildren(this); -} - -CypherParser::FunctionNameContext *CypherParser::functionName() { - FunctionNameContext *_localctx = - _tracker.createInstance(_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(0); -} - -std::vector 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(0); } -size_t CypherParser::ListComprehensionContext::getRuleIndex() const { - return CypherParser::RuleListComprehension; +std::vector 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(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(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(visitor)) - return parserVisitor->visitListComprehension(this); + +antlrcpp::Any CypherParser::ParenthesizedExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitParenthesizedExpression(this); else return visitor->visitChildren(this); } -CypherParser::ListComprehensionContext *CypherParser::listComprehension() { - ListComprehensionContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 130, CypherParser::RuleListComprehension); +CypherParser::ParenthesizedExpressionContext* CypherParser::parenthesizedExpression() { + ParenthesizedExpressionContext *_localctx = _tracker.createInstance(_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()->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(0); +} + +std::vector CypherParser::RelationshipsPatternContext::patternElementChain() { + return getRuleContexts(); +} + +CypherParser::PatternElementChainContext* CypherParser::RelationshipsPatternContext::patternElementChain(size_t i) { + return getRuleContext(i); +} + +std::vector 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(listener); + if (parserListener != nullptr) + parserListener->enterRelationshipsPattern(this); +} + +void CypherParser::RelationshipsPatternContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitRelationshipsPattern(this); +} + + +antlrcpp::Any CypherParser::RelationshipsPatternContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitRelationshipsPattern(this); + else + return visitor->visitChildren(this); +} + +CypherParser::RelationshipsPatternContext* CypherParser::relationshipsPattern() { + RelationshipsPatternContext *_localctx = _tracker.createInstance(_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()->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(0); +} + +CypherParser::WhereContext* CypherParser::FilterExpressionContext::where() { + return getRuleContext(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(listener); + if (parserListener != nullptr) + parserListener->enterFilterExpression(this); +} + +void CypherParser::FilterExpressionContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFilterExpression(this); +} + + +antlrcpp::Any CypherParser::FilterExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFilterExpression(this); + else + return visitor->visitChildren(this); +} + +CypherParser::FilterExpressionContext* CypherParser::filterExpression() { + FilterExpressionContext *_localctx = _tracker.createInstance(_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()->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(0); +} + +std::vector 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(0); +} + + +size_t CypherParser::IdInCollContext::getRuleIndex() const { + return CypherParser::RuleIdInColl; +} + +void CypherParser::IdInCollContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterIdInColl(this); +} + +void CypherParser::IdInCollContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitIdInColl(this); +} + + +antlrcpp::Any CypherParser::IdInCollContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIdInColl(this); + else + return visitor->visitChildren(this); +} + +CypherParser::IdInCollContext* CypherParser::idInColl() { + IdInCollContext *_localctx = _tracker.createInstance(_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(0); +} + +std::vector 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::FunctionInvocationContext::expression() { + return getRuleContexts(); +} + +CypherParser::ExpressionContext* CypherParser::FunctionInvocationContext::expression(size_t i) { + return getRuleContext(i); +} + + +size_t CypherParser::FunctionInvocationContext::getRuleIndex() const { + return CypherParser::RuleFunctionInvocation; +} + +void CypherParser::FunctionInvocationContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterFunctionInvocation(this); +} + +void CypherParser::FunctionInvocationContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFunctionInvocation(this); +} + + +antlrcpp::Any CypherParser::FunctionInvocationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFunctionInvocation(this); + else + return visitor->visitChildren(this); +} + +CypherParser::FunctionInvocationContext* CypherParser::functionInvocation() { + FunctionInvocationContext *_localctx = _tracker.createInstance(_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(0); -} - -std::vector 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(listener); - if (parserListener != nullptr) parserListener->enterPropertyLookup(this); -} - -void CypherParser::PropertyLookupContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitPropertyLookup(this); -} - -antlrcpp::Any CypherParser::PropertyLookupContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitPropertyLookup(this); - else - return visitor->visitChildren(this); -} - -CypherParser::PropertyLookupContext *CypherParser::propertyLookup() { - PropertyLookupContext *_localctx = - _tracker.createInstance(_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()->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()->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(0); -} - -size_t CypherParser::VariableContext::getRuleIndex() const { - return CypherParser::RuleVariable; -} - -void CypherParser::VariableContext::enterRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterVariable(this); -} - -void CypherParser::VariableContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitVariable(this); -} - -antlrcpp::Any CypherParser::VariableContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitVariable(this); - else - return visitor->visitChildren(this); -} - -CypherParser::VariableContext *CypherParser::variable() { - VariableContext *_localctx = - _tracker.createInstance(_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(0); -} - -CypherParser::IntegerLiteralContext * -CypherParser::NumberLiteralContext::integerLiteral() { - return getRuleContext(0); -} - -size_t CypherParser::NumberLiteralContext::getRuleIndex() const { - return CypherParser::RuleNumberLiteral; -} - -void CypherParser::NumberLiteralContext::enterRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterNumberLiteral(this); -} - -void CypherParser::NumberLiteralContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitNumberLiteral(this); -} - -antlrcpp::Any CypherParser::NumberLiteralContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitNumberLiteral(this); - else - return visitor->visitChildren(this); -} - -CypherParser::NumberLiteralContext *CypherParser::numberLiteral() { - NumberLiteralContext *_localctx = - _tracker.createInstance(_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 CypherParser::MapLiteralContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode *CypherParser::MapLiteralContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -std::vector -CypherParser::MapLiteralContext::propertyKeyName() { - return getRuleContexts(); -} - -CypherParser::PropertyKeyNameContext * -CypherParser::MapLiteralContext::propertyKeyName(size_t i) { - return getRuleContext(i); -} - -std::vector -CypherParser::MapLiteralContext::expression() { - return getRuleContexts(); -} - -CypherParser::ExpressionContext *CypherParser::MapLiteralContext::expression( - size_t i) { - return getRuleContext(i); -} - -size_t CypherParser::MapLiteralContext::getRuleIndex() const { - return CypherParser::RuleMapLiteral; -} - -void CypherParser::MapLiteralContext::enterRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->enterMapLiteral(this); -} - -void CypherParser::MapLiteralContext::exitRule( - tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) parserListener->exitMapLiteral(this); -} - -antlrcpp::Any CypherParser::MapLiteralContext::accept( - tree::ParseTreeVisitor *visitor) { - if (auto parserVisitor = dynamic_cast(visitor)) - return parserVisitor->visitMapLiteral(this); - else - return visitor->visitChildren(this); -} - -CypherParser::MapLiteralContext *CypherParser::mapLiteral() { - MapLiteralContext *_localctx = - _tracker.createInstance(_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(listener); + if (parserListener != nullptr) + parserListener->enterFunctionName(this); +} + +void CypherParser::FunctionNameContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitFunctionName(this); +} + + +antlrcpp::Any CypherParser::FunctionNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFunctionName(this); + else + return visitor->visitChildren(this); +} + +CypherParser::FunctionNameContext* CypherParser::functionName() { + FunctionNameContext *_localctx = _tracker.createInstance(_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(0); +} + +std::vector 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(0); +} + + +size_t CypherParser::ListComprehensionContext::getRuleIndex() const { + return CypherParser::RuleListComprehension; +} + +void CypherParser::ListComprehensionContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterListComprehension(this); +} + +void CypherParser::ListComprehensionContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitListComprehension(this); +} + + +antlrcpp::Any CypherParser::ListComprehensionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitListComprehension(this); + else + return visitor->visitChildren(this); +} + +CypherParser::ListComprehensionContext* CypherParser::listComprehension() { + ListComprehensionContext *_localctx = _tracker.createInstance(_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()->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(0); +} + +std::vector CypherParser::PatternComprehensionContext::expression() { + return getRuleContexts(); +} + +CypherParser::ExpressionContext* CypherParser::PatternComprehensionContext::expression(size_t i) { + return getRuleContext(i); +} + +std::vector 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(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(listener); + if (parserListener != nullptr) + parserListener->enterPatternComprehension(this); +} + +void CypherParser::PatternComprehensionContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPatternComprehension(this); +} + + +antlrcpp::Any CypherParser::PatternComprehensionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPatternComprehension(this); + else + return visitor->visitChildren(this); +} + +CypherParser::PatternComprehensionContext* CypherParser::patternComprehension() { + PatternComprehensionContext *_localctx = _tracker.createInstance(_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(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(listener); + if (parserListener != nullptr) + parserListener->enterPropertyLookup(this); +} + +void CypherParser::PropertyLookupContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitPropertyLookup(this); +} + + +antlrcpp::Any CypherParser::PropertyLookupContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPropertyLookup(this); + else + return visitor->visitChildren(this); +} + +CypherParser::PropertyLookupContext* CypherParser::propertyLookup() { + PropertyLookupContext *_localctx = _tracker.createInstance(_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(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(listener); + if (parserListener != nullptr) + parserListener->enterVariable(this); +} + +void CypherParser::VariableContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitVariable(this); +} + + +antlrcpp::Any CypherParser::VariableContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVariable(this); + else + return visitor->visitChildren(this); +} + +CypherParser::VariableContext* CypherParser::variable() { + VariableContext *_localctx = _tracker.createInstance(_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(0); +} + +CypherParser::IntegerLiteralContext* CypherParser::NumberLiteralContext::integerLiteral() { + return getRuleContext(0); +} + + +size_t CypherParser::NumberLiteralContext::getRuleIndex() const { + return CypherParser::RuleNumberLiteral; +} + +void CypherParser::NumberLiteralContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterNumberLiteral(this); +} + +void CypherParser::NumberLiteralContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitNumberLiteral(this); +} + + +antlrcpp::Any CypherParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNumberLiteral(this); + else + return visitor->visitChildren(this); +} + +CypherParser::NumberLiteralContext* CypherParser::numberLiteral() { + NumberLiteralContext *_localctx = _tracker.createInstance(_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 CypherParser::MapLiteralContext::SP() { + return getTokens(CypherParser::SP); +} + +tree::TerminalNode* CypherParser::MapLiteralContext::SP(size_t i) { + return getToken(CypherParser::SP, i); +} + +std::vector CypherParser::MapLiteralContext::propertyKeyName() { + return getRuleContexts(); +} + +CypherParser::PropertyKeyNameContext* CypherParser::MapLiteralContext::propertyKeyName(size_t i) { + return getRuleContext(i); +} + +std::vector CypherParser::MapLiteralContext::expression() { + return getRuleContexts(); +} + +CypherParser::ExpressionContext* CypherParser::MapLiteralContext::expression(size_t i) { + return getRuleContext(i); +} + + +size_t CypherParser::MapLiteralContext::getRuleIndex() const { + return CypherParser::RuleMapLiteral; +} + +void CypherParser::MapLiteralContext::enterRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->enterMapLiteral(this); +} + +void CypherParser::MapLiteralContext::exitRule(tree::ParseTreeListener *listener) { + auto parserListener = dynamic_cast(listener); + if (parserListener != nullptr) + parserListener->exitMapLiteral(this); +} + + +antlrcpp::Any CypherParser::MapLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMapLiteral(this); + else + return visitor->visitChildren(this); +} + +CypherParser::MapLiteralContext* CypherParser::mapLiteral() { + MapLiteralContext *_localctx = _tracker.createInstance(_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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::ParameterContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitParameter(this); else return visitor->visitChildren(this); } -CypherParser::ParameterContext *CypherParser::parameter() { - ParameterContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 140, CypherParser::RuleParameter); +CypherParser::ParameterContext* CypherParser::parameter() { + ParameterContext *_localctx = _tracker.createInstance(_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(0); } -std::vector -CypherParser::PropertyExpressionContext::propertyLookup() { +std::vector CypherParser::PropertyExpressionContext::propertyLookup() { return getRuleContexts(); } -CypherParser::PropertyLookupContext * -CypherParser::PropertyExpressionContext::propertyLookup(size_t i) { +CypherParser::PropertyLookupContext* CypherParser::PropertyExpressionContext::propertyLookup(size_t i) { return getRuleContext(i); } -std::vector -CypherParser::PropertyExpressionContext::SP() { +std::vector 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(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(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(visitor)) + +antlrcpp::Any CypherParser::PropertyExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPropertyExpression(this); else return visitor->visitChildren(this); } -CypherParser::PropertyExpressionContext *CypherParser::propertyExpression() { - PropertyExpressionContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 142, CypherParser::RulePropertyExpression); +CypherParser::PropertyExpressionContext* CypherParser::propertyExpression() { + PropertyExpressionContext *_localctx = _tracker.createInstance(_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()->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()->adaptivePredict( - _input, 218, _ctx); + alt = getInterpreter()->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(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(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(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(visitor)) + +antlrcpp::Any CypherParser::PropertyKeyNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitPropertyKeyName(this); else return visitor->visitChildren(this); } -CypherParser::PropertyKeyNameContext *CypherParser::propertyKeyName() { - PropertyKeyNameContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 144, CypherParser::RulePropertyKeyName); +CypherParser::PropertyKeyNameContext* CypherParser::propertyKeyName() { + PropertyKeyNameContext *_localctx = _tracker.createInstance(_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(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(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(visitor)) + +antlrcpp::Any CypherParser::IntegerLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitIntegerLiteral(this); else return visitor->visitChildren(this); } -CypherParser::IntegerLiteralContext *CypherParser::integerLiteral() { - IntegerLiteralContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 146, CypherParser::RuleIntegerLiteral); +CypherParser::IntegerLiteralContext* CypherParser::integerLiteral() { + IntegerLiteralContext *_localctx = _tracker.createInstance(_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(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(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(visitor)) + +antlrcpp::Any CypherParser::DoubleLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitDoubleLiteral(this); else return visitor->visitChildren(this); } -CypherParser::DoubleLiteralContext *CypherParser::doubleLiteral() { - DoubleLiteralContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 148, CypherParser::RuleDoubleLiteral); +CypherParser::DoubleLiteralContext* CypherParser::doubleLiteral() { + DoubleLiteralContext *_localctx = _tracker.createInstance(_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(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(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(visitor)) + +antlrcpp::Any CypherParser::SymbolicNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSymbolicName(this); else return visitor->visitChildren(this); } -CypherParser::SymbolicNameContext *CypherParser::symbolicName() { - SymbolicNameContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 150, CypherParser::RuleSymbolicName); +CypherParser::SymbolicNameContext* CypherParser::symbolicName() { + SymbolicNameContext *_localctx = _tracker.createInstance(_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(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(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(visitor)) + +antlrcpp::Any CypherParser::LeftArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitLeftArrowHead(this); else return visitor->visitChildren(this); } -CypherParser::LeftArrowHeadContext *CypherParser::leftArrowHead() { - LeftArrowHeadContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 152, CypherParser::RuleLeftArrowHead); +CypherParser::LeftArrowHeadContext* CypherParser::leftArrowHead() { + LeftArrowHeadContext *_localctx = _tracker.createInstance(_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(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(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(visitor)) + +antlrcpp::Any CypherParser::RightArrowHeadContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitRightArrowHead(this); else return visitor->visitChildren(this); } -CypherParser::RightArrowHeadContext *CypherParser::rightArrowHead() { - RightArrowHeadContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 154, CypherParser::RuleRightArrowHead); +CypherParser::RightArrowHeadContext* CypherParser::rightArrowHead() { + RightArrowHeadContext *_localctx = _tracker.createInstance(_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(listener); - if (parserListener != nullptr) parserListener->enterDash(this); + if (parserListener != nullptr) + parserListener->enterDash(this); } void CypherParser::DashContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(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(visitor)) + +antlrcpp::Any CypherParser::DashContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitDash(this); else return visitor->visitChildren(this); } -CypherParser::DashContext *CypherParser::dash() { - DashContext *_localctx = - _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 156, CypherParser::RuleDash); +CypherParser::DashContext* CypherParser::dash() { + DashContext *_localctx = _tracker.createInstance(_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 CypherParser::_serializedATN; std::vector 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 CypherParser::_literalNames = { - "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", - "'?'", "']'", "':'", "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", - "'^'", "'=~'", "'<>'", "'!='", "'<'", "'>'", "'<='", "'>='", "'.'", - "'!'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", "'﹤'", "'＜'", "'⟩'", - "'〉'", "'﹥'", "'＞'", "'­'", "'‐'", "'‑'", "'‒'", "'–'", "'—'", - "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", - "", "", "", "", "", "", "", "'0'"}; + "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'", + "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='", + "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", + "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "'­'", "'‐'", "'‑'", "'‒'", + "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "", + "", "", "", "", "", "'0'" +}; std::vector 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 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(""); - } else { + if (name.empty()) { + _tokenNames.push_back(""); + } 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 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 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 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 nodeLabels(); NodeLabelsContext* nodeLabels(size_t i); + std::vector 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 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 expression(); + ExpressionContext* expression(size_t i); + std::vector 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 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() 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() 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() 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() 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::Value>() 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 +#include +#include +#include +#include + +#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 it(std::cin); + std::istream_iterator 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 auto FilterAnies(std::unordered_map 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(symbol_table_); nodes_ = FilterAnies(symbol_table_); @@ -51,7 +53,7 @@ void CompareNodes(std::pair node_entry, std::vector labels, std::vector 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 node_property_keys; @@ -72,7 +74,7 @@ void CompareRelationships( std::vector 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 out3 = {1, 2, true, "a", 1, 2, true, "a"}; EXPECT_PROP_EQ( (TypedValue(2) + TypedValue(in)).Value>(), out1); - std::cerr << (TypedValue(2) + TypedValue(in)) << "\n"; EXPECT_PROP_EQ( (TypedValue(in) + TypedValue(2)).Value>(), 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)); +}