diff --git a/.gitignore b/.gitignore index 3a852fd9b..ac57d8373 100644 --- a/.gitignore +++ b/.gitignore @@ -25,3 +25,4 @@ cmake-build-* .idea cmake/DownloadProject/ dist/ +src/query/frontend/opencypher/generated/ diff --git a/src/query/backend/cpp/typed_value.hpp b/src/query/backend/cpp/typed_value.hpp index aadd7aa41..3b9bae134 100644 --- a/src/query/backend/cpp/typed_value.hpp +++ b/src/query/backend/cpp/typed_value.hpp @@ -96,7 +96,7 @@ class TypedValue : public TotalOrdering { template T Value() const; - friend std::ostream& operator<<(std::ostream& stream, const TypedValue& prop); + friend std::ostream& operator<<(std::ostream& stream, const TypedValue&prop); private: // storage for the value of the property diff --git a/src/query/entry.hpp b/src/query/entry.hpp index 29b23451f..59fab4238 100644 --- a/src/query/entry.hpp +++ b/src/query/entry.hpp @@ -43,7 +43,7 @@ class Engine { logical_plan->WriteHeader(stream); auto symbols = logical_plan->OutputSymbols(symbol_table); while (cursor->pull(frame, symbol_table)) { - std::vector values(symbols.size()); + std::vector values; for (auto symbol : symbols) { values.emplace_back(frame[symbol.position_]); } diff --git a/src/query/frontend/ast/ast.hpp b/src/query/frontend/ast/ast.hpp index b7617a746..2522186ea 100644 --- a/src/query/frontend/ast/ast.hpp +++ b/src/query/frontend/ast/ast.hpp @@ -187,10 +187,9 @@ public: class Return : public Clause { public: Return(int uid) : Clause(uid) {} - std::vector> exprs_; void Accept(TreeVisitorBase &visitor) override { visitor.PreVisit(*this); - for (auto &expr : exprs_) { + for (auto &expr : named_exprs_) { expr->Accept(visitor); } visitor.Visit(*this); diff --git a/src/query/frontend/ast/cypher_main_visitor.cpp b/src/query/frontend/ast/cypher_main_visitor.cpp index cd94df5cb..036a5c2ca 100644 --- a/src/query/frontend/ast/cypher_main_visitor.cpp +++ b/src/query/frontend/ast/cypher_main_visitor.cpp @@ -41,10 +41,9 @@ namespace { antlrcpp::Any CypherMainVisitor::visitSingleQuery(CypherParser::SingleQueryContext *ctx) { - auto children = ctx->children; - query_ = std::make_shared(ctx_.next_uid()); - for (auto *child : children) { - query_->clauses_.push_back(child->accept(this)); +query_ = std::make_shared(ctx_.next_uid()); + for (auto *child : ctx->clause()) { + query_->clauses_.push_back(child->accept(this).as>()); } return query_; } @@ -57,7 +56,11 @@ CypherMainVisitor::visitCypherMatch(CypherParser::CypherMatchContext *ctx) { } match->patterns_ = ctx->pattern()->accept(this).as>>(); - return match; + return std::shared_ptr(std::move(match)); +} + +antlrcpp::Any CypherMainVisitor::visitReturnBody(CypherParser::ReturnBodyContext *ctx) { +return ctx->returnItems()->accept(this); } antlrcpp::Any @@ -66,7 +69,7 @@ CypherMainVisitor::visitReturnItems(CypherParser::ReturnItemsContext *ctx) { for (auto *item : ctx->returnItem()) { return_clause->named_exprs_.push_back(item->accept(this)); } - return return_clause; + return std::shared_ptr(std::move(return_clause)); } antlrcpp::Any @@ -85,7 +88,7 @@ CypherMainVisitor::visitReturnItem(CypherParser::ReturnItemContext *ctx) { antlrcpp::Any CypherMainVisitor::visitNodePattern(CypherParser::NodePatternContext *ctx) { - auto node = new NodePart(ctx_.next_uid()); + auto node = std::make_shared(ctx_.next_uid()); if (ctx->variable()) { std::string variable = ctx->variable()->accept(this); node->identifier_ = @@ -107,7 +110,7 @@ CypherMainVisitor::visitNodePattern(CypherParser::NodePatternContext *ctx) { // .as>(); } - return (Part *)node; + return std::shared_ptr(std::move(node)); } antlrcpp::Any @@ -179,7 +182,7 @@ antlrcpp::Any CypherMainVisitor::visitPatternElement( if (ctx->patternElement()) { return ctx->patternElement()->accept(this); } - auto pattern = std::shared_ptr(); + auto pattern = std::make_shared(ctx_.next_uid()); pattern->parts_.push_back( ctx->nodePattern()->accept(this).as>()); for (auto *pattern_element_chain : ctx->patternElementChain()) { @@ -287,7 +290,7 @@ CypherMainVisitor::visitRangeLiteral(CypherParser::RangeLiteralContext *ctx) { antlrcpp::Any CypherMainVisitor::visitExpression(CypherParser::ExpressionContext *ctx) { - return visitChildren(ctx); + return visitChildren(ctx); } //// OR. @@ -513,7 +516,9 @@ antlrcpp::Any CypherMainVisitor::visitAtom(CypherParser::AtomContext *ctx) { return ctx->parenthesizedExpression()->accept(this); } else if (ctx->variable()) { std::string variable = ctx->variable()->accept(this); - return std::make_shared(ctx_.next_uid(), variable); + return std::shared_ptr(std::make_shared(ctx_.next_uid(), + kUserIdentPrefix + + variable)); } // TODO: Implement this. We don't support comprehensions, functions, // filtering... at the moment. diff --git a/src/query/frontend/ast/cypher_main_visitor.hpp b/src/query/frontend/ast/cypher_main_visitor.hpp index ae0569ca8..04addcd2d 100644 --- a/src/query/frontend/ast/cypher_main_visitor.hpp +++ b/src/query/frontend/ast/cypher_main_visitor.hpp @@ -55,6 +55,8 @@ private: antlrcpp::Any visitCypherMatch(CypherParser::CypherMatchContext *ctx) override; +antlrcpp::Any visitReturnBody(CypherParser::ReturnBodyContext *ctx) override; + antlrcpp::Any visitReturnItems(CypherParser::ReturnItemsContext *ctx) override; diff --git a/src/query/frontend/logical/operator.hpp b/src/query/frontend/logical/operator.hpp index 228cfc2bf..eeb41cdc9 100644 --- a/src/query/frontend/logical/operator.hpp +++ b/src/query/frontend/logical/operator.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include "database/graph_db_accessor.hpp" @@ -18,7 +19,8 @@ class ConsoleResultStream : public Loggable { void Result(std::vector& values) { for (auto value : values) { - logger.info(" result"); + auto va = value.Value(); + logger.info(" {}", va.labels().size()); } } @@ -36,7 +38,7 @@ class Cursor { class LogicalOperator { public: auto children() { return children_; }; - virtual std::unique_ptr MakeCursor(GraphDbAccessor db) = 0; + virtual std::unique_ptr MakeCursor(GraphDbAccessor& db) = 0; virtual void WriteHeader(ConsoleResultStream&) {} virtual std::vector OutputSymbols(SymbolTable& symbol_table) { return {}; @@ -54,7 +56,7 @@ class ScanAll : public LogicalOperator { private: class ScanAllCursor : public Cursor { public: - ScanAllCursor(ScanAll& self, GraphDbAccessor db) + ScanAllCursor(ScanAll& self, GraphDbAccessor& db) : self_(self), db_(db), vertices_(db.vertices()), @@ -72,7 +74,7 @@ class ScanAll : public LogicalOperator { private: ScanAll& self_; - GraphDbAccessor db_; + GraphDbAccessor& db_; decltype(db_.vertices()) vertices_; decltype(vertices_.begin()) vertices_it_; @@ -88,7 +90,7 @@ class ScanAll : public LogicalOperator { }; public: - std::unique_ptr MakeCursor(GraphDbAccessor db) override { + std::unique_ptr MakeCursor(GraphDbAccessor& db) override { return std::make_unique(*this, db); } @@ -110,23 +112,23 @@ class Produce : public LogicalOperator { stream.Header({"n"}); } - std::unique_ptr MakeCursor(GraphDbAccessor db) override { + std::unique_ptr MakeCursor(GraphDbAccessor& db) override { return std::make_unique(*this, db); } std::vector OutputSymbols(SymbolTable& symbol_table) override { - std::vector result(exprs_.size()); + std::vector result; for (auto named_expr : exprs_) { - result.emplace_back(symbol_table[*named_expr->ident_]); + result.emplace_back(symbol_table[*named_expr->ident_]); } return result; -} + } private: class ProduceCursor : public Cursor { public: - ProduceCursor(Produce& self, GraphDbAccessor db) - : self_(self), self_cursor_(self_.MakeCursor(db)) {} + ProduceCursor(Produce& self, GraphDbAccessor& db) + : self_(self), self_cursor_(self_.input_->MakeCursor(db)) {} bool pull(Frame& frame, SymbolTable& symbol_table) override { if (self_cursor_->pull(frame, symbol_table)) { for (auto expr : self_.exprs_) { diff --git a/src/query/frontend/logical/planner.hpp b/src/query/frontend/logical/planner.hpp index dded0b299..ef0f5d6e4 100644 --- a/src/query/frontend/logical/planner.hpp +++ b/src/query/frontend/logical/planner.hpp @@ -31,7 +31,7 @@ std::shared_ptr GenReturn( if (!current_op) { throw std::runtime_error("Not implemented"); } - return std::make_shared(current_op, ret.exprs_); + return std::make_shared(current_op, ret.named_exprs_); } std::shared_ptr Apply(Query& query) diff --git a/src/query/frontend/opencypher/generated/Cypher.tokens b/src/query/frontend/opencypher/generated/Cypher.tokens deleted file mode 100644 index cac3f8383..000000000 --- a/src/query/frontend/opencypher/generated/Cypher.tokens +++ /dev/null @@ -1,159 +0,0 @@ -T__0=1 -T__1=2 -T__2=3 -T__3=4 -T__4=5 -T__5=6 -T__6=7 -T__7=8 -T__8=9 -T__9=10 -T__10=11 -T__11=12 -T__12=13 -T__13=14 -T__14=15 -T__15=16 -T__16=17 -T__17=18 -T__18=19 -T__19=20 -T__20=21 -T__21=22 -T__22=23 -T__23=24 -T__24=25 -T__25=26 -T__26=27 -T__27=28 -T__28=29 -T__29=30 -T__30=31 -T__31=32 -T__32=33 -T__33=34 -T__34=35 -T__35=36 -T__36=37 -T__37=38 -T__38=39 -T__39=40 -T__40=41 -T__41=42 -T__42=43 -T__43=44 -T__44=45 -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 -';'=1 -','=2 -'='=3 -'+='=4 -'*'=5 -'('=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 -'0'=59 diff --git a/src/query/frontend/opencypher/generated/CypherBaseListener.cpp b/src/query/frontend/opencypher/generated/CypherBaseListener.cpp deleted file mode 100644 index 80f0fce2f..000000000 --- a/src/query/frontend/opencypher/generated/CypherBaseListener.cpp +++ /dev/null @@ -1,9 +0,0 @@ - -// 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 deleted file mode 100644 index e03e89b78..000000000 --- a/src/query/frontend/opencypher/generated/CypherBaseListener.h +++ /dev/null @@ -1,269 +0,0 @@ - -// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6 - -#pragma once - - -#include "antlr4-runtime.h" -#include "CypherListener.h" - - -namespace antlropencypher { - -/** - * This class provides an empty implementation of CypherListener, - * which can be extended to create a listener which only needs to handle a subset - * of the available methods. - */ -class CypherBaseListener : public CypherListener { -public: - - virtual void enterCypher(CypherParser::CypherContext * /*ctx*/) override { } - virtual void exitCypher(CypherParser::CypherContext * /*ctx*/) override { } - - virtual void enterStatement(CypherParser::StatementContext * /*ctx*/) override { } - virtual void exitStatement(CypherParser::StatementContext * /*ctx*/) override { } - - virtual void enterQuery(CypherParser::QueryContext * /*ctx*/) override { } - virtual void exitQuery(CypherParser::QueryContext * /*ctx*/) override { } - - virtual void enterRegularQuery(CypherParser::RegularQueryContext * /*ctx*/) override { } - virtual void exitRegularQuery(CypherParser::RegularQueryContext * /*ctx*/) override { } - - virtual void enterSingleQuery(CypherParser::SingleQueryContext * /*ctx*/) override { } - virtual void exitSingleQuery(CypherParser::SingleQueryContext * /*ctx*/) override { } - - virtual void enterCypherUnion(CypherParser::CypherUnionContext * /*ctx*/) override { } - virtual void exitCypherUnion(CypherParser::CypherUnionContext * /*ctx*/) override { } - - virtual void enterClause(CypherParser::ClauseContext * /*ctx*/) override { } - virtual void exitClause(CypherParser::ClauseContext * /*ctx*/) override { } - - virtual void enterCypherMatch(CypherParser::CypherMatchContext * /*ctx*/) override { } - virtual void exitCypherMatch(CypherParser::CypherMatchContext * /*ctx*/) override { } - - virtual void enterUnwind(CypherParser::UnwindContext * /*ctx*/) override { } - virtual void exitUnwind(CypherParser::UnwindContext * /*ctx*/) override { } - - virtual void enterMerge(CypherParser::MergeContext * /*ctx*/) override { } - virtual void exitMerge(CypherParser::MergeContext * /*ctx*/) override { } - - virtual void enterMergeAction(CypherParser::MergeActionContext * /*ctx*/) override { } - virtual void exitMergeAction(CypherParser::MergeActionContext * /*ctx*/) override { } - - virtual void enterCreate(CypherParser::CreateContext * /*ctx*/) override { } - virtual void exitCreate(CypherParser::CreateContext * /*ctx*/) override { } - - virtual void enterSet(CypherParser::SetContext * /*ctx*/) override { } - virtual void exitSet(CypherParser::SetContext * /*ctx*/) override { } - - virtual void enterSetItem(CypherParser::SetItemContext * /*ctx*/) override { } - virtual void exitSetItem(CypherParser::SetItemContext * /*ctx*/) override { } - - virtual void enterCypherDelete(CypherParser::CypherDeleteContext * /*ctx*/) override { } - virtual void exitCypherDelete(CypherParser::CypherDeleteContext * /*ctx*/) override { } - - virtual void enterRemove(CypherParser::RemoveContext * /*ctx*/) override { } - virtual void exitRemove(CypherParser::RemoveContext * /*ctx*/) override { } - - virtual void enterRemoveItem(CypherParser::RemoveItemContext * /*ctx*/) override { } - virtual void exitRemoveItem(CypherParser::RemoveItemContext * /*ctx*/) override { } - - virtual void enterWith(CypherParser::WithContext * /*ctx*/) override { } - virtual void exitWith(CypherParser::WithContext * /*ctx*/) override { } - - virtual void enterCypherReturn(CypherParser::CypherReturnContext * /*ctx*/) override { } - virtual void exitCypherReturn(CypherParser::CypherReturnContext * /*ctx*/) override { } - - virtual void enterReturnBody(CypherParser::ReturnBodyContext * /*ctx*/) override { } - virtual void exitReturnBody(CypherParser::ReturnBodyContext * /*ctx*/) override { } - - virtual void enterReturnItems(CypherParser::ReturnItemsContext * /*ctx*/) override { } - virtual void exitReturnItems(CypherParser::ReturnItemsContext * /*ctx*/) override { } - - virtual void enterReturnItem(CypherParser::ReturnItemContext * /*ctx*/) override { } - virtual void exitReturnItem(CypherParser::ReturnItemContext * /*ctx*/) override { } - - virtual void enterOrder(CypherParser::OrderContext * /*ctx*/) override { } - virtual void exitOrder(CypherParser::OrderContext * /*ctx*/) override { } - - virtual void enterSkip(CypherParser::SkipContext * /*ctx*/) override { } - virtual void exitSkip(CypherParser::SkipContext * /*ctx*/) override { } - - virtual void enterLimit(CypherParser::LimitContext * /*ctx*/) override { } - virtual void exitLimit(CypherParser::LimitContext * /*ctx*/) override { } - - virtual void enterSortItem(CypherParser::SortItemContext * /*ctx*/) override { } - virtual void exitSortItem(CypherParser::SortItemContext * /*ctx*/) override { } - - virtual void enterWhere(CypherParser::WhereContext * /*ctx*/) override { } - virtual void exitWhere(CypherParser::WhereContext * /*ctx*/) override { } - - virtual void enterPattern(CypherParser::PatternContext * /*ctx*/) override { } - virtual void exitPattern(CypherParser::PatternContext * /*ctx*/) override { } - - virtual void enterPatternPart(CypherParser::PatternPartContext * /*ctx*/) override { } - virtual void exitPatternPart(CypherParser::PatternPartContext * /*ctx*/) override { } - - virtual void enterAnonymousPatternPart(CypherParser::AnonymousPatternPartContext * /*ctx*/) override { } - virtual void exitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext * /*ctx*/) override { } - - virtual void enterPatternElement(CypherParser::PatternElementContext * /*ctx*/) override { } - virtual void exitPatternElement(CypherParser::PatternElementContext * /*ctx*/) override { } - - virtual void enterNodePattern(CypherParser::NodePatternContext * /*ctx*/) override { } - virtual void exitNodePattern(CypherParser::NodePatternContext * /*ctx*/) override { } - - virtual void enterPatternElementChain(CypherParser::PatternElementChainContext * /*ctx*/) override { } - virtual void exitPatternElementChain(CypherParser::PatternElementChainContext * /*ctx*/) override { } - - virtual void enterRelationshipPattern(CypherParser::RelationshipPatternContext * /*ctx*/) override { } - virtual void exitRelationshipPattern(CypherParser::RelationshipPatternContext * /*ctx*/) override { } - - virtual void enterRelationshipDetail(CypherParser::RelationshipDetailContext * /*ctx*/) override { } - virtual void exitRelationshipDetail(CypherParser::RelationshipDetailContext * /*ctx*/) override { } - - virtual void enterProperties(CypherParser::PropertiesContext * /*ctx*/) override { } - virtual void exitProperties(CypherParser::PropertiesContext * /*ctx*/) override { } - - virtual void enterRelationshipTypes(CypherParser::RelationshipTypesContext * /*ctx*/) override { } - virtual void exitRelationshipTypes(CypherParser::RelationshipTypesContext * /*ctx*/) override { } - - virtual void enterNodeLabels(CypherParser::NodeLabelsContext * /*ctx*/) override { } - virtual void exitNodeLabels(CypherParser::NodeLabelsContext * /*ctx*/) override { } - - virtual void enterNodeLabel(CypherParser::NodeLabelContext * /*ctx*/) override { } - virtual void exitNodeLabel(CypherParser::NodeLabelContext * /*ctx*/) override { } - - virtual void enterRangeLiteral(CypherParser::RangeLiteralContext * /*ctx*/) override { } - virtual void exitRangeLiteral(CypherParser::RangeLiteralContext * /*ctx*/) override { } - - virtual void enterLabelName(CypherParser::LabelNameContext * /*ctx*/) override { } - virtual void exitLabelName(CypherParser::LabelNameContext * /*ctx*/) override { } - - virtual void enterRelTypeName(CypherParser::RelTypeNameContext * /*ctx*/) override { } - virtual void exitRelTypeName(CypherParser::RelTypeNameContext * /*ctx*/) override { } - - virtual void enterExpression(CypherParser::ExpressionContext * /*ctx*/) override { } - virtual void exitExpression(CypherParser::ExpressionContext * /*ctx*/) override { } - - virtual void enterExpression12(CypherParser::Expression12Context * /*ctx*/) override { } - virtual void exitExpression12(CypherParser::Expression12Context * /*ctx*/) override { } - - virtual void enterExpression11(CypherParser::Expression11Context * /*ctx*/) override { } - virtual void exitExpression11(CypherParser::Expression11Context * /*ctx*/) override { } - - virtual void enterExpression10(CypherParser::Expression10Context * /*ctx*/) override { } - virtual void exitExpression10(CypherParser::Expression10Context * /*ctx*/) override { } - - virtual void enterExpression9(CypherParser::Expression9Context * /*ctx*/) override { } - virtual void exitExpression9(CypherParser::Expression9Context * /*ctx*/) override { } - - virtual void enterExpression8(CypherParser::Expression8Context * /*ctx*/) override { } - virtual void exitExpression8(CypherParser::Expression8Context * /*ctx*/) override { } - - virtual void enterExpression7(CypherParser::Expression7Context * /*ctx*/) override { } - virtual void exitExpression7(CypherParser::Expression7Context * /*ctx*/) override { } - - virtual void enterExpression6(CypherParser::Expression6Context * /*ctx*/) override { } - virtual void exitExpression6(CypherParser::Expression6Context * /*ctx*/) override { } - - virtual void enterExpression5(CypherParser::Expression5Context * /*ctx*/) override { } - virtual void exitExpression5(CypherParser::Expression5Context * /*ctx*/) override { } - - virtual void enterExpression4(CypherParser::Expression4Context * /*ctx*/) override { } - virtual void exitExpression4(CypherParser::Expression4Context * /*ctx*/) override { } - - virtual void enterExpression3(CypherParser::Expression3Context * /*ctx*/) override { } - virtual void exitExpression3(CypherParser::Expression3Context * /*ctx*/) override { } - - virtual void enterExpression2(CypherParser::Expression2Context * /*ctx*/) override { } - virtual void exitExpression2(CypherParser::Expression2Context * /*ctx*/) override { } - - virtual void enterAtom(CypherParser::AtomContext * /*ctx*/) override { } - virtual void exitAtom(CypherParser::AtomContext * /*ctx*/) override { } - - virtual void enterLiteral(CypherParser::LiteralContext * /*ctx*/) override { } - virtual void exitLiteral(CypherParser::LiteralContext * /*ctx*/) override { } - - virtual void enterBooleanLiteral(CypherParser::BooleanLiteralContext * /*ctx*/) override { } - virtual void exitBooleanLiteral(CypherParser::BooleanLiteralContext * /*ctx*/) override { } - - virtual void enterListLiteral(CypherParser::ListLiteralContext * /*ctx*/) override { } - virtual void exitListLiteral(CypherParser::ListLiteralContext * /*ctx*/) override { } - - virtual void enterPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext * /*ctx*/) override { } - virtual void exitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext * /*ctx*/) override { } - - virtual void enterParenthesizedExpression(CypherParser::ParenthesizedExpressionContext * /*ctx*/) override { } - virtual void exitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext * /*ctx*/) override { } - - virtual void enterRelationshipsPattern(CypherParser::RelationshipsPatternContext * /*ctx*/) override { } - virtual void exitRelationshipsPattern(CypherParser::RelationshipsPatternContext * /*ctx*/) override { } - - virtual void enterFilterExpression(CypherParser::FilterExpressionContext * /*ctx*/) override { } - virtual void exitFilterExpression(CypherParser::FilterExpressionContext * /*ctx*/) override { } - - virtual void enterIdInColl(CypherParser::IdInCollContext * /*ctx*/) override { } - virtual void exitIdInColl(CypherParser::IdInCollContext * /*ctx*/) override { } - - virtual void enterFunctionInvocation(CypherParser::FunctionInvocationContext * /*ctx*/) override { } - virtual void exitFunctionInvocation(CypherParser::FunctionInvocationContext * /*ctx*/) override { } - - virtual void enterFunctionName(CypherParser::FunctionNameContext * /*ctx*/) override { } - virtual void exitFunctionName(CypherParser::FunctionNameContext * /*ctx*/) override { } - - 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 { } - - virtual void enterVariable(CypherParser::VariableContext * /*ctx*/) override { } - virtual void exitVariable(CypherParser::VariableContext * /*ctx*/) override { } - - virtual void enterNumberLiteral(CypherParser::NumberLiteralContext * /*ctx*/) override { } - virtual void exitNumberLiteral(CypherParser::NumberLiteralContext * /*ctx*/) override { } - - virtual void enterMapLiteral(CypherParser::MapLiteralContext * /*ctx*/) override { } - virtual void exitMapLiteral(CypherParser::MapLiteralContext * /*ctx*/) override { } - - virtual void enterParameter(CypherParser::ParameterContext * /*ctx*/) override { } - virtual void exitParameter(CypherParser::ParameterContext * /*ctx*/) override { } - - virtual void enterPropertyExpression(CypherParser::PropertyExpressionContext * /*ctx*/) override { } - virtual void exitPropertyExpression(CypherParser::PropertyExpressionContext * /*ctx*/) override { } - - virtual void enterPropertyKeyName(CypherParser::PropertyKeyNameContext * /*ctx*/) override { } - virtual void exitPropertyKeyName(CypherParser::PropertyKeyNameContext * /*ctx*/) override { } - - virtual void enterIntegerLiteral(CypherParser::IntegerLiteralContext * /*ctx*/) override { } - virtual void exitIntegerLiteral(CypherParser::IntegerLiteralContext * /*ctx*/) override { } - - virtual void enterDoubleLiteral(CypherParser::DoubleLiteralContext * /*ctx*/) override { } - virtual void exitDoubleLiteral(CypherParser::DoubleLiteralContext * /*ctx*/) override { } - - virtual void enterSymbolicName(CypherParser::SymbolicNameContext * /*ctx*/) override { } - virtual void exitSymbolicName(CypherParser::SymbolicNameContext * /*ctx*/) override { } - - virtual void enterLeftArrowHead(CypherParser::LeftArrowHeadContext * /*ctx*/) override { } - virtual void exitLeftArrowHead(CypherParser::LeftArrowHeadContext * /*ctx*/) override { } - - virtual void enterRightArrowHead(CypherParser::RightArrowHeadContext * /*ctx*/) override { } - virtual void exitRightArrowHead(CypherParser::RightArrowHeadContext * /*ctx*/) override { } - - virtual void enterDash(CypherParser::DashContext * /*ctx*/) override { } - virtual void exitDash(CypherParser::DashContext * /*ctx*/) override { } - - - virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { } - virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { } - virtual void visitTerminal(antlr4::tree::TerminalNode * /*node*/) override { } - virtual void visitErrorNode(antlr4::tree::ErrorNode * /*node*/) override { } - -}; - -} // namespace antlropencypher diff --git a/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp b/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp deleted file mode 100644 index b2bd2f87d..000000000 --- a/src/query/frontend/opencypher/generated/CypherBaseVisitor.cpp +++ /dev/null @@ -1,9 +0,0 @@ - -// 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 deleted file mode 100644 index 511bdecd5..000000000 --- a/src/query/frontend/opencypher/generated/CypherBaseVisitor.h +++ /dev/null @@ -1,343 +0,0 @@ - -// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6 - -#pragma once - - -#include "antlr4-runtime.h" -#include "CypherVisitor.h" - - -namespace antlropencypher { - -/** - * This class provides an empty implementation of CypherVisitor, which can be - * extended to create a visitor which only needs to handle a subset of the available methods. - */ -class CypherBaseVisitor : public CypherVisitor { -public: - - virtual antlrcpp::Any visitCypher(CypherParser::CypherContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitStatement(CypherParser::StatementContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitQuery(CypherParser::QueryContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRegularQuery(CypherParser::RegularQueryContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitSingleQuery(CypherParser::SingleQueryContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitCypherUnion(CypherParser::CypherUnionContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitClause(CypherParser::ClauseContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitCypherMatch(CypherParser::CypherMatchContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitUnwind(CypherParser::UnwindContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitMerge(CypherParser::MergeContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitMergeAction(CypherParser::MergeActionContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitCreate(CypherParser::CreateContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitSet(CypherParser::SetContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitSetItem(CypherParser::SetItemContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitCypherDelete(CypherParser::CypherDeleteContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRemove(CypherParser::RemoveContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRemoveItem(CypherParser::RemoveItemContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitWith(CypherParser::WithContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitCypherReturn(CypherParser::CypherReturnContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitReturnBody(CypherParser::ReturnBodyContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitReturnItems(CypherParser::ReturnItemsContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitReturnItem(CypherParser::ReturnItemContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitOrder(CypherParser::OrderContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitSkip(CypherParser::SkipContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitLimit(CypherParser::LimitContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitSortItem(CypherParser::SortItemContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitWhere(CypherParser::WhereContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPattern(CypherParser::PatternContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPatternPart(CypherParser::PatternPartContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPatternElement(CypherParser::PatternElementContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitNodePattern(CypherParser::NodePatternContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPatternElementChain(CypherParser::PatternElementChainContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRelationshipPattern(CypherParser::RelationshipPatternContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRelationshipDetail(CypherParser::RelationshipDetailContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitProperties(CypherParser::PropertiesContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRelationshipTypes(CypherParser::RelationshipTypesContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitNodeLabels(CypherParser::NodeLabelsContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitNodeLabel(CypherParser::NodeLabelContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRangeLiteral(CypherParser::RangeLiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitLabelName(CypherParser::LabelNameContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRelTypeName(CypherParser::RelTypeNameContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression(CypherParser::ExpressionContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression12(CypherParser::Expression12Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression11(CypherParser::Expression11Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression10(CypherParser::Expression10Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression9(CypherParser::Expression9Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression8(CypherParser::Expression8Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression7(CypherParser::Expression7Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression6(CypherParser::Expression6Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression5(CypherParser::Expression5Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression4(CypherParser::Expression4Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression3(CypherParser::Expression3Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitExpression2(CypherParser::Expression2Context *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitAtom(CypherParser::AtomContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitLiteral(CypherParser::LiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitBooleanLiteral(CypherParser::BooleanLiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitListLiteral(CypherParser::ListLiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRelationshipsPattern(CypherParser::RelationshipsPatternContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFilterExpression(CypherParser::FilterExpressionContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitIdInColl(CypherParser::IdInCollContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFunctionInvocation(CypherParser::FunctionInvocationContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitFunctionName(CypherParser::FunctionNameContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitListComprehension(CypherParser::ListComprehensionContext *ctx) override { - 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); - } - - virtual antlrcpp::Any visitVariable(CypherParser::VariableContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitNumberLiteral(CypherParser::NumberLiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitMapLiteral(CypherParser::MapLiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitParameter(CypherParser::ParameterContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPropertyExpression(CypherParser::PropertyExpressionContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitPropertyKeyName(CypherParser::PropertyKeyNameContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitDoubleLiteral(CypherParser::DoubleLiteralContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitSymbolicName(CypherParser::SymbolicNameContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitLeftArrowHead(CypherParser::LeftArrowHeadContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitRightArrowHead(CypherParser::RightArrowHeadContext *ctx) override { - return visitChildren(ctx); - } - - virtual antlrcpp::Any visitDash(CypherParser::DashContext *ctx) override { - return visitChildren(ctx); - } - - -}; - -} // namespace antlropencypher diff --git a/src/query/frontend/opencypher/generated/CypherLexer.cpp b/src/query/frontend/opencypher/generated/CypherLexer.cpp deleted file mode 100644 index aa6be5fb7..000000000 --- a/src/query/frontend/opencypher/generated/CypherLexer.cpp +++ /dev/null @@ -1,929 +0,0 @@ - -// 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() { - delete _interpreter; -} - -std::string CypherLexer::getGrammarFileName() const { - return "Cypher.g4"; -} - -const std::vector& CypherLexer::getRuleNames() const { - return _ruleNames; -} - -const std::vector& CypherLexer::getModeNames() const { - return _modeNames; -} - -const std::vector& CypherLexer::getTokenNames() const { - return _tokenNames; -} - -dfa::Vocabulary& CypherLexer::getVocabulary() const { - return _vocabulary; -} - -const std::vector CypherLexer::getSerializedATN() const { - return _serializedATN; -} - -const atn::ATN& CypherLexer::getATN() const { - return _atn; -} - - - - -// Static vars and initialization. -std::vector CypherLexer::_decisionToDFA; -atn::PredictionContextCache CypherLexer::_sharedContextCache; - -// We own the ATN which in turn owns the ATN states. -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", "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::_literalNames = { - "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'", - "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='", - "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", - "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "'­'", "'‐'", "'‑'", "'‒'", - "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "", - "", "", "", "", "", "'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" -}; - -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); - } - - if (name.empty()) { - _tokenNames.push_back(""); - } else { - _tokenNames.push_back(name); - } - } - - _serializedATN = { - 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; - _atn = deserializer.deserialize(_serializedATN); - - size_t count = _atn.getNumberOfDecisions(); - _decisionToDFA.reserve(count); - for (size_t i = 0; i < count; i++) { - _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); - } -} - -CypherLexer::Initializer CypherLexer::_init; diff --git a/src/query/frontend/opencypher/generated/CypherLexer.h b/src/query/frontend/opencypher/generated/CypherLexer.h deleted file mode 100644 index d1dcb0516..000000000 --- a/src/query/frontend/opencypher/generated/CypherLexer.h +++ /dev/null @@ -1,75 +0,0 @@ - -// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6 - -#pragma once - - -#include "antlr4-runtime.h" - - -namespace antlropencypher { - - -class CypherLexer : public antlr4::Lexer { -public: - enum { - T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, - T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, - T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, - T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, - T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, - T__32 = 33, T__33 = 34, T__34 = 35, T__35 = 36, T__36 = 37, T__37 = 38, - T__38 = 39, T__39 = 40, T__40 = 41, T__41 = 42, T__42 = 43, T__43 = 44, - T__44 = 45, 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); - ~CypherLexer(); - - virtual std::string getGrammarFileName() const override; - virtual const std::vector& getRuleNames() const override; - - virtual const std::vector& getModeNames() const override; - virtual const std::vector& getTokenNames() const override; // deprecated, use vocabulary instead - virtual antlr4::dfa::Vocabulary& getVocabulary() const override; - - virtual const std::vector getSerializedATN() const override; - virtual const antlr4::atn::ATN& getATN() const override; - -private: - static std::vector _decisionToDFA; - static antlr4::atn::PredictionContextCache _sharedContextCache; - static std::vector _ruleNames; - static std::vector _tokenNames; - static std::vector _modeNames; - - static std::vector _literalNames; - static std::vector _symbolicNames; - static antlr4::dfa::Vocabulary _vocabulary; - static antlr4::atn::ATN _atn; - static std::vector _serializedATN; - - - // Individual action functions triggered by action() above. - - // Individual semantic predicate functions triggered by sempred() above. - - struct Initializer { - Initializer(); - }; - static Initializer _init; -}; - -} // namespace antlropencypher diff --git a/src/query/frontend/opencypher/generated/CypherLexer.tokens b/src/query/frontend/opencypher/generated/CypherLexer.tokens deleted file mode 100644 index cac3f8383..000000000 --- a/src/query/frontend/opencypher/generated/CypherLexer.tokens +++ /dev/null @@ -1,159 +0,0 @@ -T__0=1 -T__1=2 -T__2=3 -T__3=4 -T__4=5 -T__5=6 -T__6=7 -T__7=8 -T__8=9 -T__9=10 -T__10=11 -T__11=12 -T__12=13 -T__13=14 -T__14=15 -T__15=16 -T__16=17 -T__17=18 -T__18=19 -T__19=20 -T__20=21 -T__21=22 -T__22=23 -T__23=24 -T__24=25 -T__25=26 -T__26=27 -T__27=28 -T__28=29 -T__29=30 -T__30=31 -T__31=32 -T__32=33 -T__33=34 -T__34=35 -T__35=36 -T__36=37 -T__37=38 -T__38=39 -T__39=40 -T__40=41 -T__41=42 -T__42=43 -T__43=44 -T__44=45 -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 -';'=1 -','=2 -'='=3 -'+='=4 -'*'=5 -'('=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 -'0'=59 diff --git a/src/query/frontend/opencypher/generated/CypherListener.cpp b/src/query/frontend/opencypher/generated/CypherListener.cpp deleted file mode 100644 index 67176a5b5..000000000 --- a/src/query/frontend/opencypher/generated/CypherListener.cpp +++ /dev/null @@ -1,9 +0,0 @@ - -// 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 deleted file mode 100644 index 4a1128f83..000000000 --- a/src/query/frontend/opencypher/generated/CypherListener.h +++ /dev/null @@ -1,262 +0,0 @@ - -// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6 - -#pragma once - - -#include "antlr4-runtime.h" -#include "CypherParser.h" - - -namespace antlropencypher { - -/** - * This interface defines an abstract listener for a parse tree produced by CypherParser. - */ -class CypherListener : public antlr4::tree::ParseTreeListener { -public: - - virtual void enterCypher(CypherParser::CypherContext *ctx) = 0; - virtual void exitCypher(CypherParser::CypherContext *ctx) = 0; - - virtual void enterStatement(CypherParser::StatementContext *ctx) = 0; - virtual void exitStatement(CypherParser::StatementContext *ctx) = 0; - - virtual void enterQuery(CypherParser::QueryContext *ctx) = 0; - virtual void exitQuery(CypherParser::QueryContext *ctx) = 0; - - virtual void enterRegularQuery(CypherParser::RegularQueryContext *ctx) = 0; - virtual void exitRegularQuery(CypherParser::RegularQueryContext *ctx) = 0; - - virtual void enterSingleQuery(CypherParser::SingleQueryContext *ctx) = 0; - virtual void exitSingleQuery(CypherParser::SingleQueryContext *ctx) = 0; - - virtual void enterCypherUnion(CypherParser::CypherUnionContext *ctx) = 0; - virtual void exitCypherUnion(CypherParser::CypherUnionContext *ctx) = 0; - - virtual void enterClause(CypherParser::ClauseContext *ctx) = 0; - virtual void exitClause(CypherParser::ClauseContext *ctx) = 0; - - virtual void enterCypherMatch(CypherParser::CypherMatchContext *ctx) = 0; - virtual void exitCypherMatch(CypherParser::CypherMatchContext *ctx) = 0; - - virtual void enterUnwind(CypherParser::UnwindContext *ctx) = 0; - virtual void exitUnwind(CypherParser::UnwindContext *ctx) = 0; - - virtual void enterMerge(CypherParser::MergeContext *ctx) = 0; - virtual void exitMerge(CypherParser::MergeContext *ctx) = 0; - - virtual void enterMergeAction(CypherParser::MergeActionContext *ctx) = 0; - virtual void exitMergeAction(CypherParser::MergeActionContext *ctx) = 0; - - virtual void enterCreate(CypherParser::CreateContext *ctx) = 0; - virtual void exitCreate(CypherParser::CreateContext *ctx) = 0; - - virtual void enterSet(CypherParser::SetContext *ctx) = 0; - virtual void exitSet(CypherParser::SetContext *ctx) = 0; - - virtual void enterSetItem(CypherParser::SetItemContext *ctx) = 0; - virtual void exitSetItem(CypherParser::SetItemContext *ctx) = 0; - - virtual void enterCypherDelete(CypherParser::CypherDeleteContext *ctx) = 0; - virtual void exitCypherDelete(CypherParser::CypherDeleteContext *ctx) = 0; - - virtual void enterRemove(CypherParser::RemoveContext *ctx) = 0; - virtual void exitRemove(CypherParser::RemoveContext *ctx) = 0; - - virtual void enterRemoveItem(CypherParser::RemoveItemContext *ctx) = 0; - virtual void exitRemoveItem(CypherParser::RemoveItemContext *ctx) = 0; - - virtual void enterWith(CypherParser::WithContext *ctx) = 0; - virtual void exitWith(CypherParser::WithContext *ctx) = 0; - - virtual void enterCypherReturn(CypherParser::CypherReturnContext *ctx) = 0; - virtual void exitCypherReturn(CypherParser::CypherReturnContext *ctx) = 0; - - virtual void enterReturnBody(CypherParser::ReturnBodyContext *ctx) = 0; - virtual void exitReturnBody(CypherParser::ReturnBodyContext *ctx) = 0; - - virtual void enterReturnItems(CypherParser::ReturnItemsContext *ctx) = 0; - virtual void exitReturnItems(CypherParser::ReturnItemsContext *ctx) = 0; - - virtual void enterReturnItem(CypherParser::ReturnItemContext *ctx) = 0; - virtual void exitReturnItem(CypherParser::ReturnItemContext *ctx) = 0; - - virtual void enterOrder(CypherParser::OrderContext *ctx) = 0; - virtual void exitOrder(CypherParser::OrderContext *ctx) = 0; - - virtual void enterSkip(CypherParser::SkipContext *ctx) = 0; - virtual void exitSkip(CypherParser::SkipContext *ctx) = 0; - - virtual void enterLimit(CypherParser::LimitContext *ctx) = 0; - virtual void exitLimit(CypherParser::LimitContext *ctx) = 0; - - virtual void enterSortItem(CypherParser::SortItemContext *ctx) = 0; - virtual void exitSortItem(CypherParser::SortItemContext *ctx) = 0; - - virtual void enterWhere(CypherParser::WhereContext *ctx) = 0; - virtual void exitWhere(CypherParser::WhereContext *ctx) = 0; - - virtual void enterPattern(CypherParser::PatternContext *ctx) = 0; - virtual void exitPattern(CypherParser::PatternContext *ctx) = 0; - - virtual void enterPatternPart(CypherParser::PatternPartContext *ctx) = 0; - virtual void exitPatternPart(CypherParser::PatternPartContext *ctx) = 0; - - virtual void enterAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *ctx) = 0; - virtual void exitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *ctx) = 0; - - virtual void enterPatternElement(CypherParser::PatternElementContext *ctx) = 0; - virtual void exitPatternElement(CypherParser::PatternElementContext *ctx) = 0; - - virtual void enterNodePattern(CypherParser::NodePatternContext *ctx) = 0; - virtual void exitNodePattern(CypherParser::NodePatternContext *ctx) = 0; - - virtual void enterPatternElementChain(CypherParser::PatternElementChainContext *ctx) = 0; - virtual void exitPatternElementChain(CypherParser::PatternElementChainContext *ctx) = 0; - - virtual void enterRelationshipPattern(CypherParser::RelationshipPatternContext *ctx) = 0; - virtual void exitRelationshipPattern(CypherParser::RelationshipPatternContext *ctx) = 0; - - virtual void enterRelationshipDetail(CypherParser::RelationshipDetailContext *ctx) = 0; - virtual void exitRelationshipDetail(CypherParser::RelationshipDetailContext *ctx) = 0; - - virtual void enterProperties(CypherParser::PropertiesContext *ctx) = 0; - virtual void exitProperties(CypherParser::PropertiesContext *ctx) = 0; - - virtual void enterRelationshipTypes(CypherParser::RelationshipTypesContext *ctx) = 0; - virtual void exitRelationshipTypes(CypherParser::RelationshipTypesContext *ctx) = 0; - - virtual void enterNodeLabels(CypherParser::NodeLabelsContext *ctx) = 0; - virtual void exitNodeLabels(CypherParser::NodeLabelsContext *ctx) = 0; - - virtual void enterNodeLabel(CypherParser::NodeLabelContext *ctx) = 0; - virtual void exitNodeLabel(CypherParser::NodeLabelContext *ctx) = 0; - - virtual void enterRangeLiteral(CypherParser::RangeLiteralContext *ctx) = 0; - virtual void exitRangeLiteral(CypherParser::RangeLiteralContext *ctx) = 0; - - virtual void enterLabelName(CypherParser::LabelNameContext *ctx) = 0; - virtual void exitLabelName(CypherParser::LabelNameContext *ctx) = 0; - - virtual void enterRelTypeName(CypherParser::RelTypeNameContext *ctx) = 0; - virtual void exitRelTypeName(CypherParser::RelTypeNameContext *ctx) = 0; - - virtual void enterExpression(CypherParser::ExpressionContext *ctx) = 0; - virtual void exitExpression(CypherParser::ExpressionContext *ctx) = 0; - - virtual void enterExpression12(CypherParser::Expression12Context *ctx) = 0; - virtual void exitExpression12(CypherParser::Expression12Context *ctx) = 0; - - virtual void enterExpression11(CypherParser::Expression11Context *ctx) = 0; - virtual void exitExpression11(CypherParser::Expression11Context *ctx) = 0; - - virtual void enterExpression10(CypherParser::Expression10Context *ctx) = 0; - virtual void exitExpression10(CypherParser::Expression10Context *ctx) = 0; - - virtual void enterExpression9(CypherParser::Expression9Context *ctx) = 0; - virtual void exitExpression9(CypherParser::Expression9Context *ctx) = 0; - - virtual void enterExpression8(CypherParser::Expression8Context *ctx) = 0; - virtual void exitExpression8(CypherParser::Expression8Context *ctx) = 0; - - virtual void enterExpression7(CypherParser::Expression7Context *ctx) = 0; - virtual void exitExpression7(CypherParser::Expression7Context *ctx) = 0; - - virtual void enterExpression6(CypherParser::Expression6Context *ctx) = 0; - virtual void exitExpression6(CypherParser::Expression6Context *ctx) = 0; - - virtual void enterExpression5(CypherParser::Expression5Context *ctx) = 0; - virtual void exitExpression5(CypherParser::Expression5Context *ctx) = 0; - - virtual void enterExpression4(CypherParser::Expression4Context *ctx) = 0; - virtual void exitExpression4(CypherParser::Expression4Context *ctx) = 0; - - virtual void enterExpression3(CypherParser::Expression3Context *ctx) = 0; - virtual void exitExpression3(CypherParser::Expression3Context *ctx) = 0; - - virtual void enterExpression2(CypherParser::Expression2Context *ctx) = 0; - virtual void exitExpression2(CypherParser::Expression2Context *ctx) = 0; - - virtual void enterAtom(CypherParser::AtomContext *ctx) = 0; - virtual void exitAtom(CypherParser::AtomContext *ctx) = 0; - - virtual void enterLiteral(CypherParser::LiteralContext *ctx) = 0; - virtual void exitLiteral(CypherParser::LiteralContext *ctx) = 0; - - virtual void enterBooleanLiteral(CypherParser::BooleanLiteralContext *ctx) = 0; - virtual void exitBooleanLiteral(CypherParser::BooleanLiteralContext *ctx) = 0; - - virtual void enterListLiteral(CypherParser::ListLiteralContext *ctx) = 0; - virtual void exitListLiteral(CypherParser::ListLiteralContext *ctx) = 0; - - virtual void enterPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *ctx) = 0; - virtual void exitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *ctx) = 0; - - virtual void enterParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *ctx) = 0; - virtual void exitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *ctx) = 0; - - virtual void enterRelationshipsPattern(CypherParser::RelationshipsPatternContext *ctx) = 0; - virtual void exitRelationshipsPattern(CypherParser::RelationshipsPatternContext *ctx) = 0; - - virtual void enterFilterExpression(CypherParser::FilterExpressionContext *ctx) = 0; - virtual void exitFilterExpression(CypherParser::FilterExpressionContext *ctx) = 0; - - virtual void enterIdInColl(CypherParser::IdInCollContext *ctx) = 0; - virtual void exitIdInColl(CypherParser::IdInCollContext *ctx) = 0; - - virtual void enterFunctionInvocation(CypherParser::FunctionInvocationContext *ctx) = 0; - virtual void exitFunctionInvocation(CypherParser::FunctionInvocationContext *ctx) = 0; - - virtual void enterFunctionName(CypherParser::FunctionNameContext *ctx) = 0; - virtual void exitFunctionName(CypherParser::FunctionNameContext *ctx) = 0; - - 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; - - virtual void enterVariable(CypherParser::VariableContext *ctx) = 0; - virtual void exitVariable(CypherParser::VariableContext *ctx) = 0; - - virtual void enterNumberLiteral(CypherParser::NumberLiteralContext *ctx) = 0; - virtual void exitNumberLiteral(CypherParser::NumberLiteralContext *ctx) = 0; - - virtual void enterMapLiteral(CypherParser::MapLiteralContext *ctx) = 0; - virtual void exitMapLiteral(CypherParser::MapLiteralContext *ctx) = 0; - - virtual void enterParameter(CypherParser::ParameterContext *ctx) = 0; - virtual void exitParameter(CypherParser::ParameterContext *ctx) = 0; - - virtual void enterPropertyExpression(CypherParser::PropertyExpressionContext *ctx) = 0; - virtual void exitPropertyExpression(CypherParser::PropertyExpressionContext *ctx) = 0; - - virtual void enterPropertyKeyName(CypherParser::PropertyKeyNameContext *ctx) = 0; - virtual void exitPropertyKeyName(CypherParser::PropertyKeyNameContext *ctx) = 0; - - virtual void enterIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) = 0; - virtual void exitIntegerLiteral(CypherParser::IntegerLiteralContext *ctx) = 0; - - virtual void enterDoubleLiteral(CypherParser::DoubleLiteralContext *ctx) = 0; - virtual void exitDoubleLiteral(CypherParser::DoubleLiteralContext *ctx) = 0; - - virtual void enterSymbolicName(CypherParser::SymbolicNameContext *ctx) = 0; - virtual void exitSymbolicName(CypherParser::SymbolicNameContext *ctx) = 0; - - virtual void enterLeftArrowHead(CypherParser::LeftArrowHeadContext *ctx) = 0; - virtual void exitLeftArrowHead(CypherParser::LeftArrowHeadContext *ctx) = 0; - - virtual void enterRightArrowHead(CypherParser::RightArrowHeadContext *ctx) = 0; - virtual void exitRightArrowHead(CypherParser::RightArrowHeadContext *ctx) = 0; - - virtual void enterDash(CypherParser::DashContext *ctx) = 0; - virtual void exitDash(CypherParser::DashContext *ctx) = 0; - - -}; - -} // namespace antlropencypher diff --git a/src/query/frontend/opencypher/generated/CypherParser.cpp b/src/query/frontend/opencypher/generated/CypherParser.cpp deleted file mode 100644 index 0063fc0a1..000000000 --- a/src/query/frontend/opencypher/generated/CypherParser.cpp +++ /dev/null @@ -1,10627 +0,0 @@ - -// 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); -} - -CypherParser::~CypherParser() { - delete _interpreter; -} - -std::string CypherParser::getGrammarFileName() const { - return "Cypher.g4"; -} - -const std::vector& CypherParser::getRuleNames() const { - return _ruleNames; -} - -dfa::Vocabulary& CypherParser::getVocabulary() const { - return _vocabulary; -} - - -//----------------- CypherContext ------------------------------------------------------------------ - -CypherParser::CypherContext::CypherContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::StatementContext* CypherParser::CypherContext::statement() { - return getRuleContext(0); -} - -std::vector CypherParser::CypherContext::SP() { - return getTokens(CypherParser::SP); -} - -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); -} - -void CypherParser::CypherContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitCypher(this); -} - - -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()); - enterRule(_localctx, 0, CypherParser::RuleCypher); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(161); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(160); - match(CypherParser::SP); - } - setState(163); - statement(); - setState(168); - _errHandler->sync(this); - - 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); - } - - return _localctx; -} - -//----------------- StatementContext ------------------------------------------------------------------ - -CypherParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::QueryContext* CypherParser::StatementContext::query() { - return getRuleContext(0); -} - - -size_t CypherParser::StatementContext::getRuleIndex() const { - return CypherParser::RuleStatement; -} - -void CypherParser::StatementContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterStatement(this); -} - -void CypherParser::StatementContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitStatement(this); -} - - -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()); - enterRule(_localctx, 2, CypherParser::RuleStatement); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(173); - query(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- QueryContext ------------------------------------------------------------------ - -CypherParser::QueryContext::QueryContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -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); -} - -void CypherParser::QueryContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitQuery(this); -} - - -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()); - enterRule(_localctx, 4, CypherParser::RuleQuery); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(175); - regularQuery(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- RegularQueryContext ------------------------------------------------------------------ - -CypherParser::RegularQueryContext::RegularQueryContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::SingleQueryContext* CypherParser::RegularQueryContext::singleQuery() { - return getRuleContext(0); -} - -std::vector CypherParser::RegularQueryContext::cypherUnion() { - return getRuleContexts(); -} - -CypherParser::CypherUnionContext* CypherParser::RegularQueryContext::cypherUnion(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::RegularQueryContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterRegularQuery(this); -} - -void CypherParser::RegularQueryContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRegularQuery(this); -} - - -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()); - enterRule(_localctx, 6, CypherParser::RuleRegularQuery); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(177); - singleQuery(); - setState(184); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 5, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(179); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(178); - match(CypherParser::SP); - } - setState(181); - cypherUnion(); - } - setState(186); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 5, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- SingleQueryContext ------------------------------------------------------------------ - -CypherParser::SingleQueryContext::SingleQueryContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::SingleQueryContext::clause() { - return getRuleContexts(); -} - -CypherParser::ClauseContext* CypherParser::SingleQueryContext::clause(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::SingleQueryContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterSingleQuery(this); -} - -void CypherParser::SingleQueryContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitSingleQuery(this); -} - - -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()); - enterRule(_localctx, 8, CypherParser::RuleSingleQuery); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(187); - clause(); - setState(194); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 7, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(189); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(188); - match(CypherParser::SP); - } - setState(191); - clause(); - } - setState(196); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 7, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- CypherUnionContext ------------------------------------------------------------------ - -CypherParser::CypherUnionContext::CypherUnionContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::CypherUnionContext::UNION() { - return getToken(CypherParser::UNION, 0); -} - -std::vector CypherParser::CypherUnionContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::CypherUnionContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -tree::TerminalNode* CypherParser::CypherUnionContext::ALL() { - return getToken(CypherParser::ALL, 0); -} - -CypherParser::SingleQueryContext* CypherParser::CypherUnionContext::singleQuery() { - return getRuleContext(0); -} - - -size_t CypherParser::CypherUnionContext::getRuleIndex() const { - return CypherParser::RuleCypherUnion; -} - -void CypherParser::CypherUnionContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterCypherUnion(this); -} - -void CypherParser::CypherUnionContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitCypherUnion(this); -} - - -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()); - enterRule(_localctx, 10, CypherParser::RuleCypherUnion); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(209); - _errHandler->sync(this); - 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(203); - singleQuery(); - break; - } - - 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); - } - - return _localctx; -} - -//----------------- ClauseContext ------------------------------------------------------------------ - -CypherParser::ClauseContext::ClauseContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::CypherMatchContext* CypherParser::ClauseContext::cypherMatch() { - return getRuleContext(0); -} - -CypherParser::UnwindContext* CypherParser::ClauseContext::unwind() { - return getRuleContext(0); -} - -CypherParser::MergeContext* CypherParser::ClauseContext::merge() { - return getRuleContext(0); -} - -CypherParser::CreateContext* CypherParser::ClauseContext::create() { - return getRuleContext(0); -} - -CypherParser::SetContext* CypherParser::ClauseContext::set() { - return getRuleContext(0); -} - -CypherParser::CypherDeleteContext* CypherParser::ClauseContext::cypherDelete() { - return getRuleContext(0); -} - -CypherParser::RemoveContext* CypherParser::ClauseContext::remove() { - return getRuleContext(0); -} - -CypherParser::WithContext* CypherParser::ClauseContext::with() { - return getRuleContext(0); -} - -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); -} - -void CypherParser::ClauseContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitClause(this); -} - - -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()); - enterRule(_localctx, 12, CypherParser::RuleClause); - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(220); - _errHandler->sync(this); - switch (_input->LA(1)) { - case CypherParser::OPTIONAL: - case CypherParser::MATCH: { - enterOuterAlt(_localctx, 1); - setState(211); - cypherMatch(); - break; - } - - case CypherParser::UNWIND: { - enterOuterAlt(_localctx, 2); - setState(212); - unwind(); - break; - } - - case CypherParser::MERGE: { - enterOuterAlt(_localctx, 3); - setState(213); - merge(); - break; - } - - case CypherParser::CREATE: { - enterOuterAlt(_localctx, 4); - setState(214); - create(); - break; - } - - case CypherParser::SET: { - enterOuterAlt(_localctx, 5); - setState(215); - set(); - break; - } - - case CypherParser::DETACH: - case CypherParser::DELETE: { - enterOuterAlt(_localctx, 6); - setState(216); - cypherDelete(); - break; - } - - case CypherParser::REMOVE: { - enterOuterAlt(_localctx, 7); - setState(217); - remove(); - break; - } - - case CypherParser::WITH: { - enterOuterAlt(_localctx, 8); - setState(218); - with(); - break; - } - - case CypherParser::RETURN: { - enterOuterAlt(_localctx, 9); - setState(219); - cypherReturn(); - break; - } - - default: - throw NoViableAltException(this); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- CypherMatchContext ------------------------------------------------------------------ - -CypherParser::CypherMatchContext::CypherMatchContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::CypherMatchContext::MATCH() { - return getToken(CypherParser::MATCH, 0); -} - -CypherParser::PatternContext* CypherParser::CypherMatchContext::pattern() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::CypherMatchContext::OPTIONAL() { - return getToken(CypherParser::OPTIONAL, 0); -} - -std::vector CypherParser::CypherMatchContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::CypherMatchContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -CypherParser::WhereContext* CypherParser::CypherMatchContext::where() { - return getRuleContext(0); -} - - -size_t CypherParser::CypherMatchContext::getRuleIndex() const { - return CypherParser::RuleCypherMatch; -} - -void CypherParser::CypherMatchContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterCypherMatch(this); -} - -void CypherParser::CypherMatchContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitCypherMatch(this); -} - - -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()); - enterRule(_localctx, 14, CypherParser::RuleCypherMatch); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(224); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::OPTIONAL) { - setState(222); - match(CypherParser::OPTIONAL); - setState(223); - match(CypherParser::SP); - } - setState(226); - match(CypherParser::MATCH); - setState(228); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(227); - match(CypherParser::SP); - } - setState(230); - pattern(); - setState(235); - _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(231); - match(CypherParser::SP); - } - setState(234); - where(); - break; - } - - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- UnwindContext ------------------------------------------------------------------ - -CypherParser::UnwindContext::UnwindContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::UnwindContext::UNWIND() { - return getToken(CypherParser::UNWIND, 0); -} - -CypherParser::ExpressionContext* CypherParser::UnwindContext::expression() { - return getRuleContext(0); -} - -std::vector CypherParser::UnwindContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::UnwindContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -tree::TerminalNode* CypherParser::UnwindContext::AS() { - return getToken(CypherParser::AS, 0); -} - -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); -} - -void CypherParser::UnwindContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitUnwind(this); -} - - -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()); - enterRule(_localctx, 16, CypherParser::RuleUnwind); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(237); - match(CypherParser::UNWIND); - setState(239); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(238); - match(CypherParser::SP); - } - setState(241); - expression(); - setState(242); - match(CypherParser::SP); - setState(243); - match(CypherParser::AS); - setState(244); - match(CypherParser::SP); - setState(245); - variable(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- MergeContext ------------------------------------------------------------------ - -CypherParser::MergeContext::MergeContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::MergeContext::MERGE() { - return getToken(CypherParser::MERGE, 0); -} - -CypherParser::PatternPartContext* CypherParser::MergeContext::patternPart() { - return getRuleContext(0); -} - -std::vector CypherParser::MergeContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::MergeContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::MergeContext::mergeAction() { - return getRuleContexts(); -} - -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); -} - -void CypherParser::MergeContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitMerge(this); -} - - -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()); - enterRule(_localctx, 18, CypherParser::RuleMerge); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(247); - match(CypherParser::MERGE); - setState(249); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(248); - match(CypherParser::SP); - } - setState(251); - patternPart(); - setState(256); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 18, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(252); - match(CypherParser::SP); - setState(253); - mergeAction(); - } - setState(258); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 18, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- MergeActionContext ------------------------------------------------------------------ - -CypherParser::MergeActionContext::MergeActionContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::MergeActionContext::ON() { - return getToken(CypherParser::ON, 0); -} - -std::vector CypherParser::MergeActionContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::MergeActionContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -tree::TerminalNode* CypherParser::MergeActionContext::MATCH() { - return getToken(CypherParser::MATCH, 0); -} - -CypherParser::SetContext* CypherParser::MergeActionContext::set() { - return getRuleContext(0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterMergeAction(this); -} - -void CypherParser::MergeActionContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitMergeAction(this); -} - - -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()); - enterRule(_localctx, 20, CypherParser::RuleMergeAction); - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(269); - _errHandler->sync(this); - 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; - } - - 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); - } - - return _localctx; -} - -//----------------- CreateContext ------------------------------------------------------------------ - -CypherParser::CreateContext::CreateContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::CreateContext::CREATE() { - return getToken(CypherParser::CREATE, 0); -} - -CypherParser::PatternContext* CypherParser::CreateContext::pattern() { - return getRuleContext(0); -} - -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); -} - -void CypherParser::CreateContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitCreate(this); -} - - -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()); - enterRule(_localctx, 22, CypherParser::RuleCreate); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(271); - match(CypherParser::CREATE); - setState(273); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(272); - match(CypherParser::SP); - } - setState(275); - pattern(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- SetContext ------------------------------------------------------------------ - -CypherParser::SetContext::SetContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::SetContext::SET() { - return getToken(CypherParser::SET, 0); -} - -std::vector CypherParser::SetContext::setItem() { - return getRuleContexts(); -} - -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); -} - -void CypherParser::SetContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitSet(this); -} - - -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() { - SetContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 24, CypherParser::RuleSet); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(277); - match(CypherParser::SET); - 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(282); - match(CypherParser::T__1); - setState(283); - setItem(); - setState(288); - _errHandler->sync(this); - _la = _input->LA(1); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- SetItemContext ------------------------------------------------------------------ - -CypherParser::SetItemContext::SetItemContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::PropertyExpressionContext* CypherParser::SetItemContext::propertyExpression() { - return getRuleContext(0); -} - -CypherParser::ExpressionContext* CypherParser::SetItemContext::expression() { - return getRuleContext(0); -} - -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() { - return getRuleContext(0); -} - - -size_t CypherParser::SetItemContext::getRuleIndex() const { - return CypherParser::RuleSetItem; -} - -void CypherParser::SetItemContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterSetItem(this); -} - -void CypherParser::SetItemContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitSetItem(this); -} - - -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()); - enterRule(_localctx, 26, CypherParser::RuleSetItem); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(325); - _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 30, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(289); - propertyExpression(); - setState(291); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(290); - match(CypherParser::SP); - } - setState(293); - match(CypherParser::T__2); - setState(295); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(294); - match(CypherParser::SP); - } - setState(297); - expression(); - break; - } - - 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); - } - - return _localctx; -} - -//----------------- CypherDeleteContext ------------------------------------------------------------------ - -CypherParser::CypherDeleteContext::CypherDeleteContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::CypherDeleteContext::DELETE() { - return getToken(CypherParser::DELETE, 0); -} - -std::vector CypherParser::CypherDeleteContext::expression() { - return getRuleContexts(); -} - -CypherParser::ExpressionContext* CypherParser::CypherDeleteContext::expression(size_t i) { - return getRuleContext(i); -} - -tree::TerminalNode* CypherParser::CypherDeleteContext::DETACH() { - return getToken(CypherParser::DETACH, 0); -} - -std::vector CypherParser::CypherDeleteContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterCypherDelete(this); -} - -void CypherParser::CypherDeleteContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitCypherDelete(this); -} - - -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()); - enterRule(_localctx, 28, CypherParser::RuleCypherDelete); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(329); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::DETACH) { - setState(327); - match(CypherParser::DETACH); - setState(328); - match(CypherParser::SP); - } - setState(331); - match(CypherParser::DELETE); - setState(333); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(332); - match(CypherParser::SP); - } - setState(335); - expression(); - setState(346); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 35, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(337); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(336); - match(CypherParser::SP); - } - setState(339); - match(CypherParser::T__1); - setState(341); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(340); - match(CypherParser::SP); - } - setState(343); - expression(); - } - setState(348); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 35, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- RemoveContext ------------------------------------------------------------------ - -CypherParser::RemoveContext::RemoveContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::RemoveContext::REMOVE() { - return getToken(CypherParser::REMOVE, 0); -} - -std::vector CypherParser::RemoveContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::RemoveContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::RemoveContext::removeItem() { - return getRuleContexts(); -} - -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); -} - -void CypherParser::RemoveContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRemove(this); -} - - -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()); - enterRule(_localctx, 30, CypherParser::RuleRemove); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(349); - match(CypherParser::REMOVE); - setState(350); - match(CypherParser::SP); - setState(351); - removeItem(); - setState(362); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 38, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(353); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(352); - match(CypherParser::SP); - } - setState(355); - match(CypherParser::T__1); - setState(357); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(356); - match(CypherParser::SP); - } - setState(359); - removeItem(); - } - setState(364); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 38, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- RemoveItemContext ------------------------------------------------------------------ - -CypherParser::RemoveItemContext::RemoveItemContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::VariableContext* CypherParser::RemoveItemContext::variable() { - return getRuleContext(0); -} - -CypherParser::NodeLabelsContext* CypherParser::RemoveItemContext::nodeLabels() { - return getRuleContext(0); -} - -CypherParser::PropertyExpressionContext* CypherParser::RemoveItemContext::propertyExpression() { - return getRuleContext(0); -} - - -size_t CypherParser::RemoveItemContext::getRuleIndex() const { - return CypherParser::RuleRemoveItem; -} - -void CypherParser::RemoveItemContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterRemoveItem(this); -} - -void CypherParser::RemoveItemContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRemoveItem(this); -} - - -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()); - enterRule(_localctx, 32, CypherParser::RuleRemoveItem); - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(369); - _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 39, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(365); - variable(); - setState(366); - nodeLabels(); - break; - } - - 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); - } - - return _localctx; -} - -//----------------- WithContext ------------------------------------------------------------------ - -CypherParser::WithContext::WithContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::WithContext::WITH() { - return getToken(CypherParser::WITH, 0); -} - -std::vector CypherParser::WithContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::WithContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -CypherParser::ReturnBodyContext* CypherParser::WithContext::returnBody() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::WithContext::DISTINCT() { - return getToken(CypherParser::DISTINCT, 0); -} - -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); -} - -void CypherParser::WithContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitWith(this); -} - - -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()); - enterRule(_localctx, 34, CypherParser::RuleWith); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(371); - match(CypherParser::WITH); - setState(376); - _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(372); - match(CypherParser::SP); - } - setState(375); - match(CypherParser::DISTINCT); - break; - } - - } - setState(378); - match(CypherParser::SP); - setState(379); - returnBody(); - setState(384); - _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(380); - match(CypherParser::SP); - } - setState(383); - where(); - break; - } - - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- CypherReturnContext ------------------------------------------------------------------ - -CypherParser::CypherReturnContext::CypherReturnContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::CypherReturnContext::RETURN() { - return getToken(CypherParser::RETURN, 0); -} - -std::vector CypherParser::CypherReturnContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::CypherReturnContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -CypherParser::ReturnBodyContext* CypherParser::CypherReturnContext::returnBody() { - return getRuleContext(0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterCypherReturn(this); -} - -void CypherParser::CypherReturnContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitCypherReturn(this); -} - - -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()); - enterRule(_localctx, 36, CypherParser::RuleCypherReturn); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(386); - match(CypherParser::RETURN); - setState(391); - _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(387); - match(CypherParser::SP); - } - setState(390); - match(CypherParser::DISTINCT); - break; - } - - } - 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); - } - - return _localctx; -} - -//----------------- ReturnBodyContext ------------------------------------------------------------------ - -CypherParser::ReturnBodyContext::ReturnBodyContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::ReturnItemsContext* CypherParser::ReturnBodyContext::returnItems() { - return getRuleContext(0); -} - -std::vector CypherParser::ReturnBodyContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::ReturnBodyContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -CypherParser::OrderContext* CypherParser::ReturnBodyContext::order() { - return getRuleContext(0); -} - -CypherParser::SkipContext* CypherParser::ReturnBodyContext::skip() { - return getRuleContext(0); -} - -CypherParser::LimitContext* CypherParser::ReturnBodyContext::limit() { - return getRuleContext(0); -} - - -size_t CypherParser::ReturnBodyContext::getRuleIndex() const { - return CypherParser::RuleReturnBody; -} - -void CypherParser::ReturnBodyContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterReturnBody(this); -} - -void CypherParser::ReturnBodyContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitReturnBody(this); -} - - -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()); - enterRule(_localctx, 38, CypherParser::RuleReturnBody); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(396); - returnItems(); - setState(399); - _errHandler->sync(this); - - switch (getInterpreter()->adaptivePredict(_input, 46, _ctx)) { - case 1: { - setState(397); - match(CypherParser::SP); - setState(398); - order(); - break; - } - - } - setState(403); - _errHandler->sync(this); - - switch (getInterpreter()->adaptivePredict(_input, 47, _ctx)) { - case 1: { - setState(401); - match(CypherParser::SP); - setState(402); - skip(); - break; - } - - } - setState(407); - _errHandler->sync(this); - - switch (getInterpreter()->adaptivePredict(_input, 48, _ctx)) { - case 1: { - setState(405); - match(CypherParser::SP); - setState(406); - limit(); - break; - } - - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- ReturnItemsContext ------------------------------------------------------------------ - -CypherParser::ReturnItemsContext::ReturnItemsContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::ReturnItemsContext::returnItem() { - return getRuleContexts(); -} - -CypherParser::ReturnItemContext* CypherParser::ReturnItemsContext::returnItem(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::ReturnItemsContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterReturnItems(this); -} - -void CypherParser::ReturnItemsContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitReturnItems(this); -} - - -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()); - enterRule(_localctx, 40, CypherParser::RuleReturnItems); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - setState(437); - _errHandler->sync(this); - switch (_input->LA(1)) { - case CypherParser::T__4: { - enterOuterAlt(_localctx, 1); - setState(409); - match(CypherParser::T__4); - setState(420); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 51, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(411); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(410); - match(CypherParser::SP); - } - setState(413); - match(CypherParser::T__1); - setState(415); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(414); - match(CypherParser::SP); - } - setState(417); - returnItem(); - } - setState(422); - _errHandler->sync(this); - 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__25: - case CypherParser::T__27: - case CypherParser::StringLiteral: - case CypherParser::HexInteger: - case CypherParser::DecimalInteger: - case CypherParser::OctalInteger: - case CypherParser::HexLetter: - case CypherParser::ExponentDecimalReal: - case CypherParser::RegularDecimalReal: - case CypherParser::UNION: - case CypherParser::ALL: - case CypherParser::OPTIONAL: - case CypherParser::MATCH: - case CypherParser::UNWIND: - case CypherParser::AS: - case CypherParser::MERGE: - case CypherParser::ON: - case CypherParser::CREATE: - case CypherParser::SET: - case CypherParser::DETACH: - case CypherParser::DELETE: - case CypherParser::REMOVE: - case CypherParser::WITH: - case CypherParser::DISTINCT: - case CypherParser::RETURN: - case CypherParser::ORDER: - case CypherParser::BY: - case CypherParser::L_SKIP: - case CypherParser::LIMIT: - case CypherParser::ASCENDING: - case CypherParser::ASC: - case CypherParser::DESCENDING: - case CypherParser::DESC: - case CypherParser::WHERE: - case CypherParser::OR: - case CypherParser::XOR: - case CypherParser::AND: - case CypherParser::NOT: - case CypherParser::IN: - case CypherParser::STARTS: - case CypherParser::ENDS: - case CypherParser::CONTAINS: - case CypherParser::IS: - case CypherParser::CYPHERNULL: - case CypherParser::COUNT: - case CypherParser::FILTER: - case CypherParser::EXTRACT: - case CypherParser::ANY: - case CypherParser::NONE: - case CypherParser::SINGLE: - case CypherParser::TRUE: - case CypherParser::FALSE: - case CypherParser::UnescapedSymbolicName: - case CypherParser::EscapedSymbolicName: { - enterOuterAlt(_localctx, 2); - setState(423); - returnItem(); - setState(434); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 54, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(425); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(424); - match(CypherParser::SP); - } - setState(427); - match(CypherParser::T__1); - setState(429); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(428); - match(CypherParser::SP); - } - setState(431); - returnItem(); - } - setState(436); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 54, _ctx); - } - break; - } - - default: - throw NoViableAltException(this); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- ReturnItemContext ------------------------------------------------------------------ - -CypherParser::ReturnItemContext::ReturnItemContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::ExpressionContext* CypherParser::ReturnItemContext::expression() { - return getRuleContext(0); -} - -std::vector CypherParser::ReturnItemContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::ReturnItemContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -tree::TerminalNode* CypherParser::ReturnItemContext::AS() { - return getToken(CypherParser::AS, 0); -} - -CypherParser::VariableContext* CypherParser::ReturnItemContext::variable() { - return getRuleContext(0); -} - - -size_t CypherParser::ReturnItemContext::getRuleIndex() const { - return CypherParser::RuleReturnItem; -} - -void CypherParser::ReturnItemContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterReturnItem(this); -} - -void CypherParser::ReturnItemContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitReturnItem(this); -} - - -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()); - enterRule(_localctx, 42, CypherParser::RuleReturnItem); - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(446); - _errHandler->sync(this); - 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; - } - - 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); - } - - return _localctx; -} - -//----------------- OrderContext ------------------------------------------------------------------ - -CypherParser::OrderContext::OrderContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::OrderContext::ORDER() { - return getToken(CypherParser::ORDER, 0); -} - -std::vector CypherParser::OrderContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::OrderContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -tree::TerminalNode* CypherParser::OrderContext::BY() { - return getToken(CypherParser::BY, 0); -} - -std::vector CypherParser::OrderContext::sortItem() { - return getRuleContexts(); -} - -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); -} - -void CypherParser::OrderContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitOrder(this); -} - - -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()); - enterRule(_localctx, 44, CypherParser::RuleOrder); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(448); - match(CypherParser::ORDER); - setState(449); - match(CypherParser::SP); - setState(450); - match(CypherParser::BY); - setState(451); - match(CypherParser::SP); - setState(452); - sortItem(); - setState(460); - _errHandler->sync(this); - _la = _input->LA(1); - while (_la == CypherParser::T__1) { - setState(453); - match(CypherParser::T__1); - setState(455); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(454); - match(CypherParser::SP); - } - setState(457); - sortItem(); - setState(462); - _errHandler->sync(this); - _la = _input->LA(1); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- SkipContext ------------------------------------------------------------------ - -CypherParser::SkipContext::SkipContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::SkipContext::L_SKIP() { - return getToken(CypherParser::L_SKIP, 0); -} - -tree::TerminalNode* CypherParser::SkipContext::SP() { - return getToken(CypherParser::SP, 0); -} - -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); -} - -void CypherParser::SkipContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitSkip(this); -} - - -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()); - enterRule(_localctx, 46, CypherParser::RuleSkip); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(463); - match(CypherParser::L_SKIP); - setState(464); - match(CypherParser::SP); - setState(465); - expression(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- LimitContext ------------------------------------------------------------------ - -CypherParser::LimitContext::LimitContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::LimitContext::LIMIT() { - return getToken(CypherParser::LIMIT, 0); -} - -tree::TerminalNode* CypherParser::LimitContext::SP() { - return getToken(CypherParser::SP, 0); -} - -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); -} - -void CypherParser::LimitContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitLimit(this); -} - - -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()); - enterRule(_localctx, 48, CypherParser::RuleLimit); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(467); - match(CypherParser::LIMIT); - setState(468); - match(CypherParser::SP); - setState(469); - expression(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- SortItemContext ------------------------------------------------------------------ - -CypherParser::SortItemContext::SortItemContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::ExpressionContext* CypherParser::SortItemContext::expression() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::SortItemContext::ASCENDING() { - return getToken(CypherParser::ASCENDING, 0); -} - -tree::TerminalNode* CypherParser::SortItemContext::ASC() { - return getToken(CypherParser::ASC, 0); -} - -tree::TerminalNode* CypherParser::SortItemContext::DESCENDING() { - return getToken(CypherParser::DESCENDING, 0); -} - -tree::TerminalNode* CypherParser::SortItemContext::DESC() { - return getToken(CypherParser::DESC, 0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterSortItem(this); -} - -void CypherParser::SortItemContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitSortItem(this); -} - - -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()); - enterRule(_localctx, 50, CypherParser::RuleSortItem); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(471); - expression(); - setState(476); - _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(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) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- WhereContext ------------------------------------------------------------------ - -CypherParser::WhereContext::WhereContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::WhereContext::WHERE() { - return getToken(CypherParser::WHERE, 0); -} - -tree::TerminalNode* CypherParser::WhereContext::SP() { - return getToken(CypherParser::SP, 0); -} - -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); -} - -void CypherParser::WhereContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitWhere(this); -} - - -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()); - enterRule(_localctx, 52, CypherParser::RuleWhere); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(478); - match(CypherParser::WHERE); - setState(479); - match(CypherParser::SP); - setState(480); - expression(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- PatternContext ------------------------------------------------------------------ - -CypherParser::PatternContext::PatternContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::PatternContext::patternPart() { - return getRuleContexts(); -} - -CypherParser::PatternPartContext* CypherParser::PatternContext::patternPart(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::PatternContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterPattern(this); -} - -void CypherParser::PatternContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitPattern(this); -} - - -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()); - enterRule(_localctx, 54, CypherParser::RulePattern); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(482); - patternPart(); - setState(493); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 63, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(484); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(483); - match(CypherParser::SP); - } - setState(486); - match(CypherParser::T__1); - setState(488); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(487); - match(CypherParser::SP); - } - setState(490); - patternPart(); - } - setState(495); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 63, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- PatternPartContext ------------------------------------------------------------------ - -CypherParser::PatternPartContext::PatternPartContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::VariableContext* CypherParser::PatternPartContext::variable() { - return getRuleContext(0); -} - -CypherParser::AnonymousPatternPartContext* CypherParser::PatternPartContext::anonymousPatternPart() { - return getRuleContext(0); -} - -std::vector CypherParser::PatternPartContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterPatternPart(this); -} - -void CypherParser::PatternPartContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitPatternPart(this); -} - - -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()); - enterRule(_localctx, 56, CypherParser::RulePatternPart); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(507); - _errHandler->sync(this); - switch (_input->LA(1)) { - case CypherParser::HexLetter: - case CypherParser::UNION: - case CypherParser::ALL: - case CypherParser::OPTIONAL: - case CypherParser::MATCH: - case CypherParser::UNWIND: - case CypherParser::AS: - case CypherParser::MERGE: - case CypherParser::ON: - case CypherParser::CREATE: - case CypherParser::SET: - case CypherParser::DETACH: - case CypherParser::DELETE: - case CypherParser::REMOVE: - case CypherParser::WITH: - case CypherParser::DISTINCT: - case CypherParser::RETURN: - case CypherParser::ORDER: - case CypherParser::BY: - case CypherParser::L_SKIP: - case CypherParser::LIMIT: - case CypherParser::ASCENDING: - case CypherParser::ASC: - case CypherParser::DESCENDING: - case CypherParser::DESC: - case CypherParser::WHERE: - case CypherParser::OR: - case CypherParser::XOR: - case CypherParser::AND: - case CypherParser::NOT: - case CypherParser::IN: - case CypherParser::STARTS: - case CypherParser::ENDS: - case CypherParser::CONTAINS: - case CypherParser::IS: - case CypherParser::CYPHERNULL: - case CypherParser::COUNT: - case CypherParser::FILTER: - case CypherParser::EXTRACT: - case CypherParser::ANY: - case CypherParser::NONE: - case CypherParser::SINGLE: - case CypherParser::TRUE: - case CypherParser::FALSE: - case CypherParser::UnescapedSymbolicName: - case CypherParser::EscapedSymbolicName: { - enterOuterAlt(_localctx, 1); - setState(496); - variable(); - setState(498); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(497); - match(CypherParser::SP); - } - setState(500); - match(CypherParser::T__2); - setState(502); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(501); - match(CypherParser::SP); - } - setState(504); - anonymousPatternPart(); - break; - } - - case CypherParser::T__5: { - enterOuterAlt(_localctx, 2); - setState(506); - anonymousPatternPart(); - break; - } - - default: - throw NoViableAltException(this); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- AnonymousPatternPartContext ------------------------------------------------------------------ - -CypherParser::AnonymousPatternPartContext::AnonymousPatternPartContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::PatternElementContext* CypherParser::AnonymousPatternPartContext::patternElement() { - return getRuleContext(0); -} - - -size_t CypherParser::AnonymousPatternPartContext::getRuleIndex() const { - return CypherParser::RuleAnonymousPatternPart; -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitAnonymousPatternPart(this); -} - - -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()); - enterRule(_localctx, 58, CypherParser::RuleAnonymousPatternPart); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(509); - patternElement(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- PatternElementContext ------------------------------------------------------------------ - -CypherParser::PatternElementContext::PatternElementContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::NodePatternContext* CypherParser::PatternElementContext::nodePattern() { - return getRuleContext(0); -} - -std::vector CypherParser::PatternElementContext::patternElementChain() { - return getRuleContexts(); -} - -CypherParser::PatternElementChainContext* CypherParser::PatternElementContext::patternElementChain(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::PatternElementContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::PatternElementContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -CypherParser::PatternElementContext* CypherParser::PatternElementContext::patternElement() { - return getRuleContext(0); -} - - -size_t CypherParser::PatternElementContext::getRuleIndex() const { - return CypherParser::RulePatternElement; -} - -void CypherParser::PatternElementContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterPatternElement(this); -} - -void CypherParser::PatternElementContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitPatternElement(this); -} - - -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()); - enterRule(_localctx, 60, CypherParser::RulePatternElement); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - setState(525); - _errHandler->sync(this); - 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); - - _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; - } - - 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); - } - - return _localctx; -} - -//----------------- NodePatternContext ------------------------------------------------------------------ - -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) { - return getToken(CypherParser::SP, i); -} - -CypherParser::VariableContext* CypherParser::NodePatternContext::variable() { - return getRuleContext(0); -} - -CypherParser::NodeLabelsContext* CypherParser::NodePatternContext::nodeLabels() { - return getRuleContext(0); -} - -CypherParser::PropertiesContext* CypherParser::NodePatternContext::properties() { - return getRuleContext(0); -} - - -size_t CypherParser::NodePatternContext::getRuleIndex() const { - return CypherParser::RuleNodePattern; -} - -void CypherParser::NodePatternContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterNodePattern(this); -} - -void CypherParser::NodePatternContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitNodePattern(this); -} - - -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()); - enterRule(_localctx, 62, CypherParser::RuleNodePattern); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(527); - match(CypherParser::T__5); - setState(529); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(528); - match(CypherParser::SP); - } - setState(535); - _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(531); - variable(); - setState(533); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(532); - match(CypherParser::SP); - } - } - setState(541); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::T__9) { - setState(537); - nodeLabels(); - setState(539); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(538); - match(CypherParser::SP); - } - } - setState(547); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::T__25 - - || _la == CypherParser::T__27) { - setState(543); - properties(); - setState(545); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(544); - match(CypherParser::SP); - } - } - setState(549); - match(CypherParser::T__6); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- PatternElementChainContext ------------------------------------------------------------------ - -CypherParser::PatternElementChainContext::PatternElementChainContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::RelationshipPatternContext* CypherParser::PatternElementChainContext::relationshipPattern() { - return getRuleContext(0); -} - -CypherParser::NodePatternContext* CypherParser::PatternElementChainContext::nodePattern() { - return getRuleContext(0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterPatternElementChain(this); -} - -void CypherParser::PatternElementChainContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitPatternElementChain(this); -} - - -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()); - enterRule(_localctx, 64, CypherParser::RulePatternElementChain); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(551); - relationshipPattern(); - setState(553); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(552); - match(CypherParser::SP); - } - setState(555); - nodePattern(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- RelationshipPatternContext ------------------------------------------------------------------ - -CypherParser::RelationshipPatternContext::RelationshipPatternContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::LeftArrowHeadContext* CypherParser::RelationshipPatternContext::leftArrowHead() { - return getRuleContext(0); -} - -std::vector CypherParser::RelationshipPatternContext::dash() { - return getRuleContexts(); -} - -CypherParser::DashContext* CypherParser::RelationshipPatternContext::dash(size_t i) { - return getRuleContext(i); -} - -CypherParser::RightArrowHeadContext* CypherParser::RelationshipPatternContext::rightArrowHead() { - return getRuleContext(0); -} - -std::vector CypherParser::RelationshipPatternContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::RelationshipPatternContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -CypherParser::RelationshipDetailContext* CypherParser::RelationshipPatternContext::relationshipDetail() { - return getRuleContext(0); -} - - -size_t CypherParser::RelationshipPatternContext::getRuleIndex() const { - return CypherParser::RuleRelationshipPattern; -} - -void CypherParser::RelationshipPatternContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterRelationshipPattern(this); -} - -void CypherParser::RelationshipPatternContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRelationshipPattern(this); -} - - -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()); - enterRule(_localctx, 66, CypherParser::RuleRelationshipPattern); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(621); - _errHandler->sync(this); - 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: { - setState(562); - match(CypherParser::SP); - break; - } - - } - setState(566); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::T__7) { - setState(565); - relationshipDetail(); - } - 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); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(572); - match(CypherParser::SP); - } - setState(575); - rightArrowHead(); - break; - } - - 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); - } - - return _localctx; -} - -//----------------- RelationshipDetailContext ------------------------------------------------------------------ - -CypherParser::RelationshipDetailContext::RelationshipDetailContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -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() { - return getRuleContext(0); -} - -CypherParser::RangeLiteralContext* CypherParser::RelationshipDetailContext::rangeLiteral() { - return getRuleContext(0); -} - -CypherParser::PropertiesContext* CypherParser::RelationshipDetailContext::properties() { - return getRuleContext(0); -} - - -size_t CypherParser::RelationshipDetailContext::getRuleIndex() const { - return CypherParser::RuleRelationshipDetail; -} - -void CypherParser::RelationshipDetailContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterRelationshipDetail(this); -} - -void CypherParser::RelationshipDetailContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRelationshipDetail(this); -} - - -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()); - enterRule(_localctx, 68, CypherParser::RuleRelationshipDetail); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(623); - match(CypherParser::T__7); - setState(625); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(624); - match(CypherParser::SP); - } - setState(631); - _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(627); - variable(); - setState(629); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(628); - match(CypherParser::SP); - } - } - setState(637); - _errHandler->sync(this); - - _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); - } - - 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(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) { - return getRuleContext(i); -} - -std::vector CypherParser::NodeLabelsContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterNodeLabels(this); -} - -void CypherParser::NodeLabelsContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitNodeLabels(this); -} - - -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()); - enterRule(_localctx, 74, CypherParser::RuleNodeLabels); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(675); - nodeLabel(); - setState(682); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 110, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(677); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(676); - match(CypherParser::SP); - } - setState(679); - nodeLabel(); - } - setState(684); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 110, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- NodeLabelContext ------------------------------------------------------------------ - -CypherParser::NodeLabelContext::NodeLabelContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterNodeLabel(this); -} - -void CypherParser::NodeLabelContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitNodeLabel(this); -} - - -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()); - enterRule(_localctx, 76, CypherParser::RuleNodeLabel); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(685); - match(CypherParser::T__9); - setState(687); - _errHandler->sync(this); - - _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); - } - - return _localctx; -} - -//----------------- RangeLiteralContext ------------------------------------------------------------------ - -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) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::RangeLiteralContext::integerLiteral() { - return getRuleContexts(); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterRangeLiteral(this); -} - -void CypherParser::RangeLiteralContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRangeLiteral(this); -} - - -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()); - enterRule(_localctx, 78, CypherParser::RuleRangeLiteral); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(691); - match(CypherParser::T__4); - setState(693); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(692); - match(CypherParser::SP); - } - 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(695); - integerLiteral(); - setState(697); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(696); - match(CypherParser::SP); - } - } - setState(711); - _errHandler->sync(this); - - _la = _input->LA(1); - 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(702); - match(CypherParser::SP); - } - 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(705); - integerLiteral(); - setState(707); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(706); - match(CypherParser::SP); - } - } - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- LabelNameContext ------------------------------------------------------------------ - -CypherParser::LabelNameContext::LabelNameContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::SymbolicNameContext* CypherParser::LabelNameContext::symbolicName() { - return getRuleContext(0); -} - - -size_t CypherParser::LabelNameContext::getRuleIndex() const { - return CypherParser::RuleLabelName; -} - -void CypherParser::LabelNameContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterLabelName(this); -} - -void CypherParser::LabelNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitLabelName(this); -} - - -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()); - enterRule(_localctx, 80, CypherParser::RuleLabelName); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(713); - symbolicName(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- RelTypeNameContext ------------------------------------------------------------------ - -CypherParser::RelTypeNameContext::RelTypeNameContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::SymbolicNameContext* CypherParser::RelTypeNameContext::symbolicName() { - return getRuleContext(0); -} - - -size_t CypherParser::RelTypeNameContext::getRuleIndex() const { - return CypherParser::RuleRelTypeName; -} - -void CypherParser::RelTypeNameContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterRelTypeName(this); -} - -void CypherParser::RelTypeNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRelTypeName(this); -} - - -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()); - enterRule(_localctx, 82, CypherParser::RuleRelTypeName); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(715); - symbolicName(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- ExpressionContext ------------------------------------------------------------------ - -CypherParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::Expression12Context* CypherParser::ExpressionContext::expression12() { - return getRuleContext(0); -} - - -size_t CypherParser::ExpressionContext::getRuleIndex() const { - return CypherParser::RuleExpression; -} - -void CypherParser::ExpressionContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression(this); -} - -void CypherParser::ExpressionContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression(this); -} - - -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()); - enterRule(_localctx, 84, CypherParser::RuleExpression); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(717); - expression12(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression12Context ------------------------------------------------------------------ - -CypherParser::Expression12Context::Expression12Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::Expression12Context::expression11() { - return getRuleContexts(); -} - -CypherParser::Expression11Context* CypherParser::Expression12Context::expression11(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression12Context::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::Expression12Context::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::Expression12Context::OR() { - return getTokens(CypherParser::OR); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression12(this); -} - -void CypherParser::Expression12Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression12(this); -} - - -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()); - enterRule(_localctx, 86, CypherParser::RuleExpression12); - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(719); - expression11(); - setState(726); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 119, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(720); - match(CypherParser::SP); - setState(721); - match(CypherParser::OR); - setState(722); - match(CypherParser::SP); - setState(723); - expression11(); - } - setState(728); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 119, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression11Context ------------------------------------------------------------------ - -CypherParser::Expression11Context::Expression11Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::Expression11Context::expression10() { - return getRuleContexts(); -} - -CypherParser::Expression10Context* CypherParser::Expression11Context::expression10(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression11Context::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::Expression11Context::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::Expression11Context::XOR() { - return getTokens(CypherParser::XOR); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression11(this); -} - -void CypherParser::Expression11Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression11(this); -} - - -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()); - enterRule(_localctx, 88, CypherParser::RuleExpression11); - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(729); - expression10(); - setState(736); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 120, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(730); - match(CypherParser::SP); - setState(731); - match(CypherParser::XOR); - setState(732); - match(CypherParser::SP); - setState(733); - expression10(); - } - setState(738); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 120, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression10Context ------------------------------------------------------------------ - -CypherParser::Expression10Context::Expression10Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::Expression10Context::expression9() { - return getRuleContexts(); -} - -CypherParser::Expression9Context* CypherParser::Expression10Context::expression9(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression10Context::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::Expression10Context::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::Expression10Context::AND() { - return getTokens(CypherParser::AND); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression10(this); -} - -void CypherParser::Expression10Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression10(this); -} - - -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()); - enterRule(_localctx, 90, CypherParser::RuleExpression10); - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(739); - expression9(); - setState(746); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 121, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(740); - match(CypherParser::SP); - setState(741); - match(CypherParser::AND); - setState(742); - match(CypherParser::SP); - setState(743); - expression9(); - } - setState(748); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 121, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression9Context ------------------------------------------------------------------ - -CypherParser::Expression9Context::Expression9Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::Expression8Context* CypherParser::Expression9Context::expression8() { - return getRuleContext(0); -} - -std::vector CypherParser::Expression9Context::NOT() { - return getTokens(CypherParser::NOT); -} - -tree::TerminalNode* CypherParser::Expression9Context::NOT(size_t i) { - return getToken(CypherParser::NOT, i); -} - -std::vector CypherParser::Expression9Context::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression9(this); -} - -void CypherParser::Expression9Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression9(this); -} - - -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()); - enterRule(_localctx, 92, CypherParser::RuleExpression9); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(755); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 123, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(749); - match(CypherParser::NOT); - setState(751); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(750); - match(CypherParser::SP); - } - } - setState(757); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 123, _ctx); - } - setState(758); - expression8(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression8Context ------------------------------------------------------------------ - -CypherParser::Expression8Context::Expression8Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::Expression7Context* CypherParser::Expression8Context::expression7() { - return getRuleContext(0); -} - -std::vector CypherParser::Expression8Context::partialComparisonExpression() { - return getRuleContexts(); -} - -CypherParser::PartialComparisonExpressionContext* CypherParser::Expression8Context::partialComparisonExpression(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression8Context::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression8(this); -} - -void CypherParser::Expression8Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression8(this); -} - - -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()); - enterRule(_localctx, 94, CypherParser::RuleExpression8); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(760); - expression7(); - setState(767); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 125, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(762); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(761); - match(CypherParser::SP); - } - setState(764); - partialComparisonExpression(); - } - setState(769); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 125, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression7Context ------------------------------------------------------------------ - -CypherParser::Expression7Context::Expression7Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::Expression7Context::expression6() { - return getRuleContexts(); -} - -CypherParser::Expression6Context* CypherParser::Expression7Context::expression6(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression7Context::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression7(this); -} - -void CypherParser::Expression7Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression7(this); -} - - -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()); - enterRule(_localctx, 96, CypherParser::RuleExpression7); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(770); - expression6(); - setState(789); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 131, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(787); - _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(771); - match(CypherParser::SP); - } - setState(774); - match(CypherParser::T__12); - setState(776); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(775); - match(CypherParser::SP); - } - setState(778); - expression6(); - break; - } - - 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); - } - - return _localctx; -} - -//----------------- Expression6Context ------------------------------------------------------------------ - -CypherParser::Expression6Context::Expression6Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::Expression6Context::expression5() { - return getRuleContexts(); -} - -CypherParser::Expression5Context* CypherParser::Expression6Context::expression5(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression6Context::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression6(this); -} - -void CypherParser::Expression6Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression6(this); -} - - -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()); - enterRule(_localctx, 98, CypherParser::RuleExpression6); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(792); - expression5(); - setState(819); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 139, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(817); - _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(793); - match(CypherParser::SP); - } - setState(796); - match(CypherParser::T__4); - setState(798); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(797); - match(CypherParser::SP); - } - setState(800); - expression5(); - break; - } - - 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); - } - - return _localctx; -} - -//----------------- Expression5Context ------------------------------------------------------------------ - -CypherParser::Expression5Context::Expression5Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::Expression5Context::expression4() { - return getRuleContexts(); -} - -CypherParser::Expression4Context* CypherParser::Expression5Context::expression4(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression5Context::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression5(this); -} - -void CypherParser::Expression5Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression5(this); -} - - -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()); - enterRule(_localctx, 100, CypherParser::RuleExpression5); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(822); - expression4(); - setState(833); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 142, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(824); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(823); - match(CypherParser::SP); - } - setState(826); - match(CypherParser::T__16); - setState(828); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(827); - match(CypherParser::SP); - } - setState(830); - expression4(); - } - setState(835); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 142, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression4Context ------------------------------------------------------------------ - -CypherParser::Expression4Context::Expression4Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::Expression3Context* CypherParser::Expression4Context::expression3() { - return getRuleContext(0); -} - -std::vector CypherParser::Expression4Context::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression4(this); -} - -void CypherParser::Expression4Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression4(this); -} - - -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()); - enterRule(_localctx, 102, CypherParser::RuleExpression4); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(842); - _errHandler->sync(this); - _la = _input->LA(1); - while (_la == CypherParser::T__12 - - || _la == CypherParser::T__13) { - setState(836); - _la = _input->LA(1); - if (!(_la == CypherParser::T__12 - - || _la == CypherParser::T__13)) { - _errHandler->recoverInline(this); - } - else { - _errHandler->reportMatch(this); - consume(); - } - setState(838); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(837); - match(CypherParser::SP); - } - setState(844); - _errHandler->sync(this); - _la = _input->LA(1); - } - setState(845); - expression3(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- Expression3Context ------------------------------------------------------------------ - -CypherParser::Expression3Context::Expression3Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -std::vector CypherParser::Expression3Context::expression2() { - return getRuleContexts(); -} - -CypherParser::Expression2Context* CypherParser::Expression3Context::expression2(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression3Context::expression() { - return getRuleContexts(); -} - -CypherParser::ExpressionContext* CypherParser::Expression3Context::expression(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression3Context::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::Expression3Context::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::Expression3Context::IS() { - return getTokens(CypherParser::IS); -} - -tree::TerminalNode* CypherParser::Expression3Context::IS(size_t i) { - return getToken(CypherParser::IS, i); -} - -std::vector CypherParser::Expression3Context::CYPHERNULL() { - return getTokens(CypherParser::CYPHERNULL); -} - -tree::TerminalNode* CypherParser::Expression3Context::CYPHERNULL(size_t i) { - return getToken(CypherParser::CYPHERNULL, i); -} - -std::vector CypherParser::Expression3Context::NOT() { - return getTokens(CypherParser::NOT); -} - -tree::TerminalNode* CypherParser::Expression3Context::NOT(size_t i) { - return getToken(CypherParser::NOT, i); -} - -std::vector CypherParser::Expression3Context::IN() { - return getTokens(CypherParser::IN); -} - -tree::TerminalNode* CypherParser::Expression3Context::IN(size_t i) { - return getToken(CypherParser::IN, i); -} - -std::vector CypherParser::Expression3Context::STARTS() { - return getTokens(CypherParser::STARTS); -} - -tree::TerminalNode* CypherParser::Expression3Context::STARTS(size_t i) { - return getToken(CypherParser::STARTS, i); -} - -std::vector CypherParser::Expression3Context::WITH() { - return getTokens(CypherParser::WITH); -} - -tree::TerminalNode* CypherParser::Expression3Context::WITH(size_t i) { - return getToken(CypherParser::WITH, i); -} - -std::vector CypherParser::Expression3Context::ENDS() { - return getTokens(CypherParser::ENDS); -} - -tree::TerminalNode* CypherParser::Expression3Context::ENDS(size_t i) { - return getToken(CypherParser::ENDS, i); -} - -std::vector CypherParser::Expression3Context::CONTAINS() { - return getTokens(CypherParser::CONTAINS); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression3(this); -} - -void CypherParser::Expression3Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression3(this); -} - - -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()); - enterRule(_localctx, 104, CypherParser::RuleExpression3); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(847); - expression2(); - setState(901); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 153, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - setState(899); - _errHandler->sync(this); - 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(868); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(867); - match(CypherParser::SP); - } - setState(870); - match(CypherParser::T__17); - break; - } - - case 2: { - setState(871); - match(CypherParser::SP); - setState(872); - match(CypherParser::IN); - break; - } - - case 3: { - setState(873); - match(CypherParser::SP); - setState(874); - match(CypherParser::STARTS); - setState(875); - match(CypherParser::SP); - setState(876); - match(CypherParser::WITH); - break; - } - - case 4: { - setState(877); - match(CypherParser::SP); - setState(878); - match(CypherParser::ENDS); - setState(879); - match(CypherParser::SP); - setState(880); - match(CypherParser::WITH); - break; - } - - case 5: { - setState(881); - match(CypherParser::SP); - setState(882); - match(CypherParser::CONTAINS); - break; - } - - } - 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); - } - - return _localctx; -} - -//----------------- Expression2Context ------------------------------------------------------------------ - -CypherParser::Expression2Context::Expression2Context(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::AtomContext* CypherParser::Expression2Context::atom() { - return getRuleContext(0); -} - -std::vector CypherParser::Expression2Context::propertyLookup() { - return getRuleContexts(); -} - -CypherParser::PropertyLookupContext* CypherParser::Expression2Context::propertyLookup(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::Expression2Context::nodeLabels() { - return getRuleContexts(); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpression2(this); -} - -void CypherParser::Expression2Context::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpression2(this); -} - - -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()); - enterRule(_localctx, 106, CypherParser::RuleExpression2); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(904); - atom(); - setState(914); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 156, _ctx); - while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { - if (alt == 1) { - 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__24: { - setState(908); - propertyLookup(); - break; - } - - case CypherParser::T__9: { - setState(909); - nodeLabels(); - break; - } - - default: - throw NoViableAltException(this); - } - } - setState(916); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 156, _ctx); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- AtomContext ------------------------------------------------------------------ - -CypherParser::AtomContext::AtomContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::LiteralContext* CypherParser::AtomContext::literal() { - return getRuleContext(0); -} - -CypherParser::ParameterContext* CypherParser::AtomContext::parameter() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::AtomContext::COUNT() { - return getToken(CypherParser::COUNT, 0); -} - -std::vector CypherParser::AtomContext::SP() { - return getTokens(CypherParser::SP); -} - -tree::TerminalNode* CypherParser::AtomContext::SP(size_t i) { - return getToken(CypherParser::SP, i); -} - -CypherParser::ListComprehensionContext* CypherParser::AtomContext::listComprehension() { - return getRuleContext(0); -} - -CypherParser::PatternComprehensionContext* CypherParser::AtomContext::patternComprehension() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::AtomContext::FILTER() { - return getToken(CypherParser::FILTER, 0); -} - -CypherParser::FilterExpressionContext* CypherParser::AtomContext::filterExpression() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::AtomContext::EXTRACT() { - return getToken(CypherParser::EXTRACT, 0); -} - -CypherParser::ExpressionContext* CypherParser::AtomContext::expression() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::AtomContext::ALL() { - return getToken(CypherParser::ALL, 0); -} - -tree::TerminalNode* CypherParser::AtomContext::ANY() { - return getToken(CypherParser::ANY, 0); -} - -tree::TerminalNode* CypherParser::AtomContext::NONE() { - return getToken(CypherParser::NONE, 0); -} - -tree::TerminalNode* CypherParser::AtomContext::SINGLE() { - return getToken(CypherParser::SINGLE, 0); -} - -CypherParser::RelationshipsPatternContext* CypherParser::AtomContext::relationshipsPattern() { - return getRuleContext(0); -} - -CypherParser::ParenthesizedExpressionContext* CypherParser::AtomContext::parenthesizedExpression() { - return getRuleContext(0); -} - -CypherParser::FunctionInvocationContext* CypherParser::AtomContext::functionInvocation() { - return getRuleContext(0); -} - -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); -} - -void CypherParser::AtomContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitAtom(this); -} - - -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()); - enterRule(_localctx, 108, CypherParser::RuleAtom); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(1029); - _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 180, _ctx)) { - case 1: { - enterOuterAlt(_localctx, 1); - setState(917); - literal(); - break; - } - - 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); - } - - return _localctx; -} - -//----------------- LiteralContext ------------------------------------------------------------------ - -CypherParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::NumberLiteralContext* CypherParser::LiteralContext::numberLiteral() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::LiteralContext::StringLiteral() { - return getToken(CypherParser::StringLiteral, 0); -} - -CypherParser::BooleanLiteralContext* CypherParser::LiteralContext::booleanLiteral() { - return getRuleContext(0); -} - -tree::TerminalNode* CypherParser::LiteralContext::CYPHERNULL() { - return getToken(CypherParser::CYPHERNULL, 0); -} - -CypherParser::MapLiteralContext* CypherParser::LiteralContext::mapLiteral() { - return getRuleContext(0); -} - -CypherParser::ListLiteralContext* CypherParser::LiteralContext::listLiteral() { - return getRuleContext(0); -} - - -size_t CypherParser::LiteralContext::getRuleIndex() const { - return CypherParser::RuleLiteral; -} - -void CypherParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterLiteral(this); -} - -void CypherParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitLiteral(this); -} - - -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()); - enterRule(_localctx, 110, CypherParser::RuleLiteral); - - auto onExit = finally([=] { - exitRule(); - }); - try { - setState(1037); - _errHandler->sync(this); - switch (_input->LA(1)) { - case CypherParser::HexInteger: - case CypherParser::DecimalInteger: - case CypherParser::OctalInteger: - case CypherParser::ExponentDecimalReal: - case CypherParser::RegularDecimalReal: { - enterOuterAlt(_localctx, 1); - setState(1031); - numberLiteral(); - break; - } - - case CypherParser::StringLiteral: { - enterOuterAlt(_localctx, 2); - setState(1032); - match(CypherParser::StringLiteral); - break; - } - - case CypherParser::TRUE: - case CypherParser::FALSE: { - enterOuterAlt(_localctx, 3); - setState(1033); - booleanLiteral(); - break; - } - - case CypherParser::CYPHERNULL: { - enterOuterAlt(_localctx, 4); - setState(1034); - match(CypherParser::CYPHERNULL); - break; - } - - case CypherParser::T__25: { - enterOuterAlt(_localctx, 5); - setState(1035); - mapLiteral(); - break; - } - - case CypherParser::T__7: { - enterOuterAlt(_localctx, 6); - setState(1036); - listLiteral(); - break; - } - - default: - throw NoViableAltException(this); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- BooleanLiteralContext ------------------------------------------------------------------ - -CypherParser::BooleanLiteralContext::BooleanLiteralContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::BooleanLiteralContext::TRUE() { - return getToken(CypherParser::TRUE, 0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterBooleanLiteral(this); -} - -void CypherParser::BooleanLiteralContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitBooleanLiteral(this); -} - - -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()); - enterRule(_localctx, 112, CypherParser::RuleBooleanLiteral); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1039); - _la = _input->LA(1); - if (!(_la == CypherParser::TRUE - - || _la == CypherParser::FALSE)) { - _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; -} - -//----------------- ListLiteralContext ------------------------------------------------------------------ - -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) { - return getToken(CypherParser::SP, i); -} - -std::vector CypherParser::ListLiteralContext::expression() { - return getRuleContexts(); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterListLiteral(this); -} - -void CypherParser::ListLiteralContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitListLiteral(this); -} - - -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()); - enterRule(_localctx, 114, CypherParser::RuleListLiteral); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1041); - match(CypherParser::T__7); - setState(1043); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1042); - match(CypherParser::SP); - } - 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__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(1047); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1046); - match(CypherParser::SP); - } - setState(1059); - _errHandler->sync(this); - _la = _input->LA(1); - while (_la == CypherParser::T__1) { - setState(1049); - match(CypherParser::T__1); - setState(1051); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1050); - match(CypherParser::SP); - } - setState(1053); - expression(); - setState(1055); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1054); - match(CypherParser::SP); - } - setState(1061); - _errHandler->sync(this); - _la = _input->LA(1); - } - } - setState(1064); - match(CypherParser::T__8); - - } - 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(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(1067); - match(CypherParser::SP); - } - setState(1070); - expression7(); - break; - } - - case CypherParser::T__18: { - enterOuterAlt(_localctx, 2); - setState(1071); - match(CypherParser::T__18); - setState(1073); - _errHandler->sync(this); - - _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::T__23); - setState(1098); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1097); - match(CypherParser::SP); - } - setState(1100); - 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(1103); - match(CypherParser::T__5); - setState(1105); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1104); - match(CypherParser::SP); - } - setState(1107); - expression(); - setState(1109); - _errHandler->sync(this); - - _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); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1140); - match(CypherParser::SP); - } - setState(1147); - _errHandler->sync(this); - - switch (getInterpreter()->adaptivePredict(_input, 205, _ctx)) { - case 1: { - setState(1143); - match(CypherParser::DISTINCT); - setState(1145); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1144); - match(CypherParser::SP); - } - break; - } - - } - setState(1166); - _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(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(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 == CypherParser::SP) { - setState(1173); - match(CypherParser::SP); - } - setState(1176); - filterExpression(); - setState(1185); - _errHandler->sync(this); - - switch (getInterpreter()->adaptivePredict(_input, 214, _ctx)) { - case 1: { - setState(1178); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1177); - match(CypherParser::SP); - } - setState(1180); - match(CypherParser::T__10); - setState(1182); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1181); - match(CypherParser::SP); - } - setState(1184); - expression(); - break; - } - - } - 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); - } - - return _localctx; -} - -//----------------- PatternComprehensionContext ------------------------------------------------------------------ - -CypherParser::PatternComprehensionContext::PatternComprehensionContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -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); -} - - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterParameter(this); -} - -void CypherParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitParameter(this); -} - - -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, 142, CypherParser::RuleParameter); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1283); - match(CypherParser::T__27); - setState(1286); - _errHandler->sync(this); - switch (_input->LA(1)) { - case CypherParser::HexLetter: - case CypherParser::UNION: - case CypherParser::ALL: - case CypherParser::OPTIONAL: - case CypherParser::MATCH: - case CypherParser::UNWIND: - case CypherParser::AS: - case CypherParser::MERGE: - case CypherParser::ON: - case CypherParser::CREATE: - case CypherParser::SET: - case CypherParser::DETACH: - case CypherParser::DELETE: - case CypherParser::REMOVE: - case CypherParser::WITH: - case CypherParser::DISTINCT: - case CypherParser::RETURN: - case CypherParser::ORDER: - case CypherParser::BY: - case CypherParser::L_SKIP: - case CypherParser::LIMIT: - case CypherParser::ASCENDING: - case CypherParser::ASC: - case CypherParser::DESCENDING: - case CypherParser::DESC: - case CypherParser::WHERE: - case CypherParser::OR: - case CypherParser::XOR: - case CypherParser::AND: - case CypherParser::NOT: - case CypherParser::IN: - case CypherParser::STARTS: - case CypherParser::ENDS: - case CypherParser::CONTAINS: - case CypherParser::IS: - case CypherParser::CYPHERNULL: - case CypherParser::COUNT: - case CypherParser::FILTER: - case CypherParser::EXTRACT: - case CypherParser::ANY: - case CypherParser::NONE: - case CypherParser::SINGLE: - case CypherParser::TRUE: - case CypherParser::FALSE: - case CypherParser::UnescapedSymbolicName: - case CypherParser::EscapedSymbolicName: { - setState(1284); - symbolicName(); - break; - } - - case CypherParser::DecimalInteger: { - setState(1285); - match(CypherParser::DecimalInteger); - break; - } - - default: - throw NoViableAltException(this); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- PropertyExpressionContext ------------------------------------------------------------------ - -CypherParser::PropertyExpressionContext::PropertyExpressionContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::AtomContext* CypherParser::PropertyExpressionContext::atom() { - return getRuleContext(0); -} - -std::vector CypherParser::PropertyExpressionContext::propertyLookup() { - return getRuleContexts(); -} - -CypherParser::PropertyLookupContext* CypherParser::PropertyExpressionContext::propertyLookup(size_t i) { - return getRuleContext(i); -} - -std::vector CypherParser::PropertyExpressionContext::SP() { - return getTokens(CypherParser::SP); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterPropertyExpression(this); -} - -void CypherParser::PropertyExpressionContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitPropertyExpression(this); -} - - -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, 144, CypherParser::RulePropertyExpression); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - size_t alt; - enterOuterAlt(_localctx, 1); - setState(1288); - atom(); - setState(1293); - _errHandler->sync(this); - alt = 1; - do { - switch (alt) { - case 1: { - setState(1290); - _errHandler->sync(this); - - _la = _input->LA(1); - if (_la == CypherParser::SP) { - setState(1289); - match(CypherParser::SP); - } - setState(1292); - propertyLookup(); - break; - } - - default: - throw NoViableAltException(this); - } - setState(1295); - _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 240, _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; -} - -//----------------- PropertyKeyNameContext ------------------------------------------------------------------ - -CypherParser::PropertyKeyNameContext::PropertyKeyNameContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -CypherParser::SymbolicNameContext* CypherParser::PropertyKeyNameContext::symbolicName() { - return getRuleContext(0); -} - - -size_t CypherParser::PropertyKeyNameContext::getRuleIndex() const { - return CypherParser::RulePropertyKeyName; -} - -void CypherParser::PropertyKeyNameContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterPropertyKeyName(this); -} - -void CypherParser::PropertyKeyNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitPropertyKeyName(this); -} - - -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, 146, CypherParser::RulePropertyKeyName); - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1297); - symbolicName(); - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- IntegerLiteralContext ------------------------------------------------------------------ - -CypherParser::IntegerLiteralContext::IntegerLiteralContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::IntegerLiteralContext::HexInteger() { - return getToken(CypherParser::HexInteger, 0); -} - -tree::TerminalNode* CypherParser::IntegerLiteralContext::OctalInteger() { - return getToken(CypherParser::OctalInteger, 0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterIntegerLiteral(this); -} - -void CypherParser::IntegerLiteralContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitIntegerLiteral(this); -} - - -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, 148, CypherParser::RuleIntegerLiteral); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - 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 { - _errHandler->reportMatch(this); - consume(); - } - - } - catch (RecognitionException &e) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- DoubleLiteralContext ------------------------------------------------------------------ - -CypherParser::DoubleLiteralContext::DoubleLiteralContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::DoubleLiteralContext::ExponentDecimalReal() { - return getToken(CypherParser::ExponentDecimalReal, 0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterDoubleLiteral(this); -} - -void CypherParser::DoubleLiteralContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitDoubleLiteral(this); -} - - -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, 150, CypherParser::RuleDoubleLiteral); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1301); - _la = _input->LA(1); - if (!(_la == CypherParser::ExponentDecimalReal - - || _la == CypherParser::RegularDecimalReal)) { - _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; -} - -//----------------- SymbolicNameContext ------------------------------------------------------------------ - -CypherParser::SymbolicNameContext::SymbolicNameContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::UnescapedSymbolicName() { - return getToken(CypherParser::UnescapedSymbolicName, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::EscapedSymbolicName() { - return getToken(CypherParser::EscapedSymbolicName, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::UNION() { - return getToken(CypherParser::UNION, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::ALL() { - return getToken(CypherParser::ALL, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::OPTIONAL() { - return getToken(CypherParser::OPTIONAL, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::MATCH() { - return getToken(CypherParser::MATCH, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::UNWIND() { - return getToken(CypherParser::UNWIND, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::AS() { - return getToken(CypherParser::AS, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::MERGE() { - return getToken(CypherParser::MERGE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::ON() { - return getToken(CypherParser::ON, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::CREATE() { - return getToken(CypherParser::CREATE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::SET() { - return getToken(CypherParser::SET, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::DETACH() { - return getToken(CypherParser::DETACH, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::DELETE() { - return getToken(CypherParser::DELETE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::REMOVE() { - return getToken(CypherParser::REMOVE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::WITH() { - return getToken(CypherParser::WITH, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::DISTINCT() { - return getToken(CypherParser::DISTINCT, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::RETURN() { - return getToken(CypherParser::RETURN, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::ORDER() { - return getToken(CypherParser::ORDER, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::BY() { - return getToken(CypherParser::BY, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::L_SKIP() { - return getToken(CypherParser::L_SKIP, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::LIMIT() { - return getToken(CypherParser::LIMIT, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::ASCENDING() { - return getToken(CypherParser::ASCENDING, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::ASC() { - return getToken(CypherParser::ASC, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::DESCENDING() { - return getToken(CypherParser::DESCENDING, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::DESC() { - return getToken(CypherParser::DESC, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::WHERE() { - return getToken(CypherParser::WHERE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::OR() { - return getToken(CypherParser::OR, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::XOR() { - return getToken(CypherParser::XOR, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::AND() { - return getToken(CypherParser::AND, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::NOT() { - return getToken(CypherParser::NOT, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::IN() { - return getToken(CypherParser::IN, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::STARTS() { - return getToken(CypherParser::STARTS, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::ENDS() { - return getToken(CypherParser::ENDS, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::CONTAINS() { - return getToken(CypherParser::CONTAINS, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::IS() { - return getToken(CypherParser::IS, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::CYPHERNULL() { - return getToken(CypherParser::CYPHERNULL, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::COUNT() { - return getToken(CypherParser::COUNT, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::FILTER() { - return getToken(CypherParser::FILTER, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::EXTRACT() { - return getToken(CypherParser::EXTRACT, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::ANY() { - return getToken(CypherParser::ANY, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::NONE() { - return getToken(CypherParser::NONE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::SINGLE() { - return getToken(CypherParser::SINGLE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::TRUE() { - return getToken(CypherParser::TRUE, 0); -} - -tree::TerminalNode* CypherParser::SymbolicNameContext::FALSE() { - return getToken(CypherParser::FALSE, 0); -} - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterSymbolicName(this); -} - -void CypherParser::SymbolicNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitSymbolicName(this); -} - - -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, 152, CypherParser::RuleSymbolicName); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1303); - _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))) { - _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; -} - -//----------------- LeftArrowHeadContext ------------------------------------------------------------------ - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterLeftArrowHead(this); -} - -void CypherParser::LeftArrowHeadContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitLeftArrowHead(this); -} - - -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, 154, CypherParser::RuleLeftArrowHead); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1305); - _la = _input->LA(1); - 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) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- RightArrowHeadContext ------------------------------------------------------------------ - -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) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterRightArrowHead(this); -} - -void CypherParser::RightArrowHeadContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitRightArrowHead(this); -} - - -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, 156, CypherParser::RuleRightArrowHead); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1307); - _la = _input->LA(1); - 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) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -//----------------- DashContext ------------------------------------------------------------------ - -CypherParser::DashContext::DashContext(ParserRuleContext *parent, size_t invokingState) - : ParserRuleContext(parent, invokingState) { -} - - -size_t CypherParser::DashContext::getRuleIndex() const { - return CypherParser::RuleDash; -} - -void CypherParser::DashContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterDash(this); -} - -void CypherParser::DashContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitDash(this); -} - - -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, 158, CypherParser::RuleDash); - size_t _la = 0; - - auto onExit = finally([=] { - exitRule(); - }); - try { - enterOuterAlt(_localctx, 1); - setState(1309); - _la = _input->LA(1); - 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) { - _errHandler->reportError(this, e); - _localctx->exception = std::current_exception(); - _errHandler->recover(this, _localctx->exception); - } - - return _localctx; -} - -// Static vars and initialization. -std::vector CypherParser::_decisionToDFA; -atn::PredictionContextCache CypherParser::_sharedContextCache; - -// We own the ATN which in turn owns the ATN states. -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", "patternComprehension", "propertyLookup", - "variable", "numberLiteral", "mapLiteral", "parameter", "propertyExpression", - "propertyKeyName", "integerLiteral", "doubleLiteral", "symbolicName", - "leftArrowHead", "rightArrowHead", "dash" -}; - -std::vector CypherParser::_literalNames = { - "", "';'", "','", "'='", "'+='", "'*'", "'('", "')'", "'['", "']'", "':'", - "'|'", "'..'", "'+'", "'-'", "'/'", "'%'", "'^'", "'=~'", "'<>'", "'!='", - "'<'", "'>'", "'<='", "'>='", "'.'", "'{'", "'}'", "'$'", "'⟨'", "'〈'", - "'﹤'", "'＜'", "'⟩'", "'〉'", "'﹥'", "'＞'", "'­'", "'‐'", "'‑'", "'‒'", - "'–'", "'—'", "'―'", "'−'", "'﹘'", "'﹣'", "'－'", "", "", "", "", "", "", - "", "", "", "", "", "'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" -}; - -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); - } - - if (name.empty()) { - _tokenNames.push_back(""); - } else { - _tokenNames.push_back(name); - } - } - - _serializedATN = { - 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; - _atn = deserializer.deserialize(_serializedATN); - - size_t count = _atn.getNumberOfDecisions(); - _decisionToDFA.reserve(count); - for (size_t i = 0; i < count; i++) { - _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); - } -} - -CypherParser::Initializer CypherParser::_init; diff --git a/src/query/frontend/opencypher/generated/CypherParser.h b/src/query/frontend/opencypher/generated/CypherParser.h deleted file mode 100644 index ad6859560..000000000 --- a/src/query/frontend/opencypher/generated/CypherParser.h +++ /dev/null @@ -1,1687 +0,0 @@ - -// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6 - -#pragma once - - -#include "antlr4-runtime.h" - - -namespace antlropencypher { - - -class CypherParser : public antlr4::Parser { -public: - enum { - T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, - T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, - T__14 = 15, T__15 = 16, T__16 = 17, T__17 = 18, T__18 = 19, T__19 = 20, - T__20 = 21, T__21 = 22, T__22 = 23, T__23 = 24, T__24 = 25, T__25 = 26, - T__26 = 27, T__27 = 28, T__28 = 29, T__29 = 30, T__30 = 31, T__31 = 32, - T__32 = 33, T__33 = 34, T__34 = 35, T__35 = 36, T__36 = 37, T__37 = 38, - T__38 = 39, T__39 = 40, T__40 = 41, T__41 = 42, T__42 = 43, T__43 = 44, - T__44 = 45, 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 { - RuleCypher = 0, RuleStatement = 1, RuleQuery = 2, RuleRegularQuery = 3, - RuleSingleQuery = 4, RuleCypherUnion = 5, RuleClause = 6, RuleCypherMatch = 7, - RuleUnwind = 8, RuleMerge = 9, RuleMergeAction = 10, RuleCreate = 11, - RuleSet = 12, RuleSetItem = 13, RuleCypherDelete = 14, RuleRemove = 15, - RuleRemoveItem = 16, RuleWith = 17, RuleCypherReturn = 18, RuleReturnBody = 19, - RuleReturnItems = 20, RuleReturnItem = 21, RuleOrder = 22, RuleSkip = 23, - RuleLimit = 24, RuleSortItem = 25, RuleWhere = 26, RulePattern = 27, - RulePatternPart = 28, RuleAnonymousPatternPart = 29, RulePatternElement = 30, - RuleNodePattern = 31, RulePatternElementChain = 32, RuleRelationshipPattern = 33, - RuleRelationshipDetail = 34, RuleProperties = 35, RuleRelationshipTypes = 36, - RuleNodeLabels = 37, RuleNodeLabel = 38, RuleRangeLiteral = 39, RuleLabelName = 40, - RuleRelTypeName = 41, RuleExpression = 42, RuleExpression12 = 43, RuleExpression11 = 44, - RuleExpression10 = 45, RuleExpression9 = 46, RuleExpression8 = 47, RuleExpression7 = 48, - RuleExpression6 = 49, RuleExpression5 = 50, RuleExpression4 = 51, RuleExpression3 = 52, - RuleExpression2 = 53, RuleAtom = 54, RuleLiteral = 55, RuleBooleanLiteral = 56, - RuleListLiteral = 57, RulePartialComparisonExpression = 58, RuleParenthesizedExpression = 59, - RuleRelationshipsPattern = 60, RuleFilterExpression = 61, RuleIdInColl = 62, - RuleFunctionInvocation = 63, RuleFunctionName = 64, RuleListComprehension = 65, - 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); - ~CypherParser(); - - virtual std::string getGrammarFileName() const override; - virtual const antlr4::atn::ATN& getATN() const override { return _atn; }; - virtual const std::vector& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead. - virtual const std::vector& getRuleNames() const override; - virtual antlr4::dfa::Vocabulary& getVocabulary() const override; - - - class CypherContext; - class StatementContext; - class QueryContext; - class RegularQueryContext; - class SingleQueryContext; - class CypherUnionContext; - class ClauseContext; - class CypherMatchContext; - class UnwindContext; - class MergeContext; - class MergeActionContext; - class CreateContext; - class SetContext; - class SetItemContext; - class CypherDeleteContext; - class RemoveContext; - class RemoveItemContext; - class WithContext; - class CypherReturnContext; - class ReturnBodyContext; - class ReturnItemsContext; - class ReturnItemContext; - class OrderContext; - class SkipContext; - class LimitContext; - class SortItemContext; - class WhereContext; - class PatternContext; - class PatternPartContext; - class AnonymousPatternPartContext; - class PatternElementContext; - class NodePatternContext; - class PatternElementChainContext; - class RelationshipPatternContext; - class RelationshipDetailContext; - class PropertiesContext; - class RelationshipTypesContext; - class NodeLabelsContext; - class NodeLabelContext; - class RangeLiteralContext; - class LabelNameContext; - class RelTypeNameContext; - class ExpressionContext; - class Expression12Context; - class Expression11Context; - class Expression10Context; - class Expression9Context; - class Expression8Context; - class Expression7Context; - class Expression6Context; - class Expression5Context; - class Expression4Context; - class Expression3Context; - class Expression2Context; - class AtomContext; - class LiteralContext; - class BooleanLiteralContext; - class ListLiteralContext; - class PartialComparisonExpressionContext; - class ParenthesizedExpressionContext; - class RelationshipsPatternContext; - class FilterExpressionContext; - class IdInCollContext; - class FunctionInvocationContext; - class FunctionNameContext; - class ListComprehensionContext; - class PatternComprehensionContext; - class PropertyLookupContext; - class VariableContext; - class NumberLiteralContext; - class MapLiteralContext; - class ParameterContext; - class PropertyExpressionContext; - class PropertyKeyNameContext; - class IntegerLiteralContext; - class DoubleLiteralContext; - class SymbolicNameContext; - class LeftArrowHeadContext; - class RightArrowHeadContext; - class DashContext; - - class CypherContext : public antlr4::ParserRuleContext { - public: - CypherContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - StatementContext *statement(); - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - CypherContext* cypher(); - - class StatementContext : public antlr4::ParserRuleContext { - public: - StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - QueryContext *query(); - - 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; - - }; - - StatementContext* statement(); - - class QueryContext : public antlr4::ParserRuleContext { - public: - QueryContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - RegularQueryContext *regularQuery(); - - 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; - - }; - - QueryContext* query(); - - class RegularQueryContext : public antlr4::ParserRuleContext { - public: - RegularQueryContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - SingleQueryContext *singleQuery(); - std::vector cypherUnion(); - CypherUnionContext* cypherUnion(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - RegularQueryContext* regularQuery(); - - class SingleQueryContext : public antlr4::ParserRuleContext { - public: - SingleQueryContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector clause(); - ClauseContext* clause(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - SingleQueryContext* singleQuery(); - - class CypherUnionContext : public antlr4::ParserRuleContext { - public: - CypherUnionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *UNION(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - antlr4::tree::TerminalNode *ALL(); - SingleQueryContext *singleQuery(); - - 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; - - }; - - CypherUnionContext* cypherUnion(); - - class ClauseContext : public antlr4::ParserRuleContext { - public: - ClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - CypherMatchContext *cypherMatch(); - UnwindContext *unwind(); - MergeContext *merge(); - CreateContext *create(); - SetContext *set(); - CypherDeleteContext *cypherDelete(); - RemoveContext *remove(); - WithContext *with(); - CypherReturnContext *cypherReturn(); - - 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; - - }; - - ClauseContext* clause(); - - class CypherMatchContext : public antlr4::ParserRuleContext { - public: - CypherMatchContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *MATCH(); - PatternContext *pattern(); - antlr4::tree::TerminalNode *OPTIONAL(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - WhereContext *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; - - }; - - CypherMatchContext* cypherMatch(); - - class UnwindContext : public antlr4::ParserRuleContext { - public: - UnwindContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *UNWIND(); - ExpressionContext *expression(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - antlr4::tree::TerminalNode *AS(); - VariableContext *variable(); - - 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; - - }; - - UnwindContext* unwind(); - - class MergeContext : public antlr4::ParserRuleContext { - public: - MergeContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *MERGE(); - PatternPartContext *patternPart(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector mergeAction(); - MergeActionContext* mergeAction(size_t i); - - 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; - - }; - - MergeContext* merge(); - - class MergeActionContext : public antlr4::ParserRuleContext { - public: - MergeActionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *ON(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - antlr4::tree::TerminalNode *MATCH(); - SetContext *set(); - antlr4::tree::TerminalNode *CREATE(); - - 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; - - }; - - MergeActionContext* mergeAction(); - - class CreateContext : public antlr4::ParserRuleContext { - public: - CreateContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *CREATE(); - PatternContext *pattern(); - antlr4::tree::TerminalNode *SP(); - - 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; - - }; - - CreateContext* create(); - - class SetContext : public antlr4::ParserRuleContext { - public: - SetContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - SetContext* set(); - - class SetItemContext : public antlr4::ParserRuleContext { - public: - SetItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - PropertyExpressionContext *propertyExpression(); - ExpressionContext *expression(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - VariableContext *variable(); - NodeLabelsContext *nodeLabels(); - - 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; - - }; - - SetItemContext* setItem(); - - class CypherDeleteContext : public antlr4::ParserRuleContext { - public: - CypherDeleteContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *DELETE(); - std::vector expression(); - ExpressionContext* expression(size_t i); - antlr4::tree::TerminalNode *DETACH(); - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - CypherDeleteContext* cypherDelete(); - - class RemoveContext : public antlr4::ParserRuleContext { - public: - RemoveContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *REMOVE(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector removeItem(); - RemoveItemContext* removeItem(size_t i); - - 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; - - }; - - RemoveContext* remove(); - - class RemoveItemContext : public antlr4::ParserRuleContext { - public: - RemoveItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - VariableContext *variable(); - NodeLabelsContext *nodeLabels(); - PropertyExpressionContext *propertyExpression(); - - 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; - - }; - - RemoveItemContext* removeItem(); - - class WithContext : public antlr4::ParserRuleContext { - public: - WithContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *WITH(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - ReturnBodyContext *returnBody(); - antlr4::tree::TerminalNode *DISTINCT(); - WhereContext *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; - - }; - - WithContext* with(); - - class CypherReturnContext : public antlr4::ParserRuleContext { - public: - CypherReturnContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *RETURN(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - ReturnBodyContext *returnBody(); - antlr4::tree::TerminalNode *DISTINCT(); - - 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; - - }; - - CypherReturnContext* cypherReturn(); - - class ReturnBodyContext : public antlr4::ParserRuleContext { - public: - ReturnBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - ReturnItemsContext *returnItems(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - OrderContext *order(); - SkipContext *skip(); - LimitContext *limit(); - - 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; - - }; - - ReturnBodyContext* returnBody(); - - class ReturnItemsContext : public antlr4::ParserRuleContext { - public: - ReturnItemsContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector returnItem(); - ReturnItemContext* returnItem(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - ReturnItemsContext* returnItems(); - - class ReturnItemContext : public antlr4::ParserRuleContext { - public: - ReturnItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - ExpressionContext *expression(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - antlr4::tree::TerminalNode *AS(); - VariableContext *variable(); - - 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; - - }; - - ReturnItemContext* returnItem(); - - class OrderContext : public antlr4::ParserRuleContext { - public: - OrderContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *ORDER(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - antlr4::tree::TerminalNode *BY(); - std::vector sortItem(); - SortItemContext* sortItem(size_t i); - - 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; - - }; - - OrderContext* order(); - - class SkipContext : public antlr4::ParserRuleContext { - public: - SkipContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *L_SKIP(); - antlr4::tree::TerminalNode *SP(); - ExpressionContext *expression(); - - 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; - - }; - - SkipContext* skip(); - - class LimitContext : public antlr4::ParserRuleContext { - public: - LimitContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *LIMIT(); - antlr4::tree::TerminalNode *SP(); - ExpressionContext *expression(); - - 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; - - }; - - LimitContext* limit(); - - class SortItemContext : public antlr4::ParserRuleContext { - public: - SortItemContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - ExpressionContext *expression(); - antlr4::tree::TerminalNode *ASCENDING(); - antlr4::tree::TerminalNode *ASC(); - antlr4::tree::TerminalNode *DESCENDING(); - antlr4::tree::TerminalNode *DESC(); - antlr4::tree::TerminalNode *SP(); - - 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; - - }; - - SortItemContext* sortItem(); - - class WhereContext : public antlr4::ParserRuleContext { - public: - WhereContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *WHERE(); - antlr4::tree::TerminalNode *SP(); - ExpressionContext *expression(); - - 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; - - }; - - WhereContext* where(); - - class PatternContext : public antlr4::ParserRuleContext { - public: - PatternContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector patternPart(); - PatternPartContext* patternPart(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - PatternContext* pattern(); - - class PatternPartContext : public antlr4::ParserRuleContext { - public: - PatternPartContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - VariableContext *variable(); - AnonymousPatternPartContext *anonymousPatternPart(); - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - PatternPartContext* patternPart(); - - class AnonymousPatternPartContext : public antlr4::ParserRuleContext { - public: - AnonymousPatternPartContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - PatternElementContext *patternElement(); - - 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; - - }; - - AnonymousPatternPartContext* anonymousPatternPart(); - - class PatternElementContext : public antlr4::ParserRuleContext { - public: - PatternElementContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - NodePatternContext *nodePattern(); - std::vector patternElementChain(); - PatternElementChainContext* patternElementChain(size_t i); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - PatternElementContext *patternElement(); - - 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; - - }; - - PatternElementContext* patternElement(); - - class NodePatternContext : public antlr4::ParserRuleContext { - public: - NodePatternContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - VariableContext *variable(); - NodeLabelsContext *nodeLabels(); - PropertiesContext *properties(); - - 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; - - }; - - NodePatternContext* nodePattern(); - - class PatternElementChainContext : public antlr4::ParserRuleContext { - public: - PatternElementChainContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - RelationshipPatternContext *relationshipPattern(); - NodePatternContext *nodePattern(); - antlr4::tree::TerminalNode *SP(); - - 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; - - }; - - PatternElementChainContext* patternElementChain(); - - class RelationshipPatternContext : public antlr4::ParserRuleContext { - public: - RelationshipPatternContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - LeftArrowHeadContext *leftArrowHead(); - std::vector dash(); - DashContext* dash(size_t i); - RightArrowHeadContext *rightArrowHead(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - RelationshipDetailContext *relationshipDetail(); - - 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; - - }; - - RelationshipPatternContext* relationshipPattern(); - - class RelationshipDetailContext : public antlr4::ParserRuleContext { - 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(); - PropertiesContext *properties(); - - 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; - - }; - - RelationshipDetailContext* relationshipDetail(); - - class PropertiesContext : public antlr4::ParserRuleContext { - public: - PropertiesContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - MapLiteralContext *mapLiteral(); - ParameterContext *parameter(); - - 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; - - }; - - PropertiesContext* properties(); - - class RelationshipTypesContext : public antlr4::ParserRuleContext { - public: - RelationshipTypesContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector relTypeName(); - RelTypeNameContext* relTypeName(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - RelationshipTypesContext* relationshipTypes(); - - class NodeLabelsContext : public antlr4::ParserRuleContext { - public: - NodeLabelsContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector nodeLabel(); - NodeLabelContext* nodeLabel(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - NodeLabelsContext* nodeLabels(); - - class NodeLabelContext : public antlr4::ParserRuleContext { - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - NodeLabelContext* nodeLabel(); - - class RangeLiteralContext : public antlr4::ParserRuleContext { - public: - RangeLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector integerLiteral(); - IntegerLiteralContext* integerLiteral(size_t i); - - 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; - - }; - - RangeLiteralContext* rangeLiteral(); - - class LabelNameContext : public antlr4::ParserRuleContext { - public: - LabelNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - SymbolicNameContext *symbolicName(); - - 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; - - }; - - LabelNameContext* labelName(); - - class RelTypeNameContext : public antlr4::ParserRuleContext { - public: - RelTypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - SymbolicNameContext *symbolicName(); - - 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; - - }; - - RelTypeNameContext* relTypeName(); - - class ExpressionContext : public antlr4::ParserRuleContext { - public: - ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - Expression12Context *expression12(); - - 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; - - }; - - ExpressionContext* expression(); - - class Expression12Context : public antlr4::ParserRuleContext { - public: - Expression12Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector expression11(); - Expression11Context* expression11(size_t i); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector OR(); - antlr4::tree::TerminalNode* OR(size_t i); - - 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; - - }; - - Expression12Context* expression12(); - - class Expression11Context : public antlr4::ParserRuleContext { - public: - Expression11Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector expression10(); - Expression10Context* expression10(size_t i); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector XOR(); - antlr4::tree::TerminalNode* XOR(size_t i); - - 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; - - }; - - Expression11Context* expression11(); - - class Expression10Context : public antlr4::ParserRuleContext { - public: - Expression10Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector expression9(); - Expression9Context* expression9(size_t i); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector AND(); - antlr4::tree::TerminalNode* AND(size_t i); - - 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; - - }; - - Expression10Context* expression10(); - - class Expression9Context : public antlr4::ParserRuleContext { - public: - Expression9Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - Expression8Context *expression8(); - std::vector NOT(); - antlr4::tree::TerminalNode* NOT(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - Expression9Context* expression9(); - - class Expression8Context : public antlr4::ParserRuleContext { - public: - Expression8Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - Expression7Context *expression7(); - std::vector partialComparisonExpression(); - PartialComparisonExpressionContext* partialComparisonExpression(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - Expression8Context* expression8(); - - class Expression7Context : public antlr4::ParserRuleContext { - public: - Expression7Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector expression6(); - Expression6Context* expression6(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - Expression7Context* expression7(); - - class Expression6Context : public antlr4::ParserRuleContext { - public: - Expression6Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector expression5(); - Expression5Context* expression5(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - Expression6Context* expression6(); - - class Expression5Context : public antlr4::ParserRuleContext { - public: - Expression5Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector expression4(); - Expression4Context* expression4(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - Expression5Context* expression5(); - - class Expression4Context : public antlr4::ParserRuleContext { - public: - Expression4Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - Expression3Context *expression3(); - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - Expression4Context* expression4(); - - class Expression3Context : public antlr4::ParserRuleContext { - public: - Expression3Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector expression2(); - Expression2Context* expression2(size_t i); - std::vector expression(); - ExpressionContext* expression(size_t i); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector IS(); - antlr4::tree::TerminalNode* IS(size_t i); - std::vector CYPHERNULL(); - antlr4::tree::TerminalNode* CYPHERNULL(size_t i); - std::vector NOT(); - antlr4::tree::TerminalNode* NOT(size_t i); - std::vector IN(); - antlr4::tree::TerminalNode* IN(size_t i); - std::vector STARTS(); - antlr4::tree::TerminalNode* STARTS(size_t i); - std::vector WITH(); - antlr4::tree::TerminalNode* WITH(size_t i); - std::vector ENDS(); - antlr4::tree::TerminalNode* ENDS(size_t i); - std::vector CONTAINS(); - antlr4::tree::TerminalNode* CONTAINS(size_t i); - - 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; - - }; - - Expression3Context* expression3(); - - class Expression2Context : public antlr4::ParserRuleContext { - public: - Expression2Context(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - AtomContext *atom(); - std::vector propertyLookup(); - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - Expression2Context* expression2(); - - class AtomContext : public antlr4::ParserRuleContext { - public: - AtomContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - LiteralContext *literal(); - ParameterContext *parameter(); - antlr4::tree::TerminalNode *COUNT(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - ListComprehensionContext *listComprehension(); - PatternComprehensionContext *patternComprehension(); - antlr4::tree::TerminalNode *FILTER(); - FilterExpressionContext *filterExpression(); - antlr4::tree::TerminalNode *EXTRACT(); - ExpressionContext *expression(); - antlr4::tree::TerminalNode *ALL(); - antlr4::tree::TerminalNode *ANY(); - antlr4::tree::TerminalNode *NONE(); - antlr4::tree::TerminalNode *SINGLE(); - RelationshipsPatternContext *relationshipsPattern(); - ParenthesizedExpressionContext *parenthesizedExpression(); - FunctionInvocationContext *functionInvocation(); - VariableContext *variable(); - - 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; - - }; - - AtomContext* atom(); - - class LiteralContext : public antlr4::ParserRuleContext { - public: - LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - NumberLiteralContext *numberLiteral(); - antlr4::tree::TerminalNode *StringLiteral(); - BooleanLiteralContext *booleanLiteral(); - antlr4::tree::TerminalNode *CYPHERNULL(); - MapLiteralContext *mapLiteral(); - ListLiteralContext *listLiteral(); - - 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; - - }; - - LiteralContext* literal(); - - class BooleanLiteralContext : public antlr4::ParserRuleContext { - public: - BooleanLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *TRUE(); - antlr4::tree::TerminalNode *FALSE(); - - 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; - - }; - - BooleanLiteralContext* booleanLiteral(); - - class ListLiteralContext : public antlr4::ParserRuleContext { - public: - ListLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector expression(); - ExpressionContext* expression(size_t i); - - 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; - - }; - - ListLiteralContext* listLiteral(); - - class PartialComparisonExpressionContext : public antlr4::ParserRuleContext { - public: - PartialComparisonExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - Expression7Context *expression7(); - antlr4::tree::TerminalNode *SP(); - - 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; - - }; - - PartialComparisonExpressionContext* partialComparisonExpression(); - - class ParenthesizedExpressionContext : public antlr4::ParserRuleContext { - public: - ParenthesizedExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - ExpressionContext *expression(); - 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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - ParenthesizedExpressionContext* parenthesizedExpression(); - - class RelationshipsPatternContext : public antlr4::ParserRuleContext { - public: - RelationshipsPatternContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - NodePatternContext *nodePattern(); - std::vector patternElementChain(); - PatternElementChainContext* patternElementChain(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - RelationshipsPatternContext* relationshipsPattern(); - - class FilterExpressionContext : public antlr4::ParserRuleContext { - public: - FilterExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - IdInCollContext *idInColl(); - WhereContext *where(); - antlr4::tree::TerminalNode *SP(); - - 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; - - }; - - FilterExpressionContext* filterExpression(); - - class IdInCollContext : public antlr4::ParserRuleContext { - public: - IdInCollContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - VariableContext *variable(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - antlr4::tree::TerminalNode *IN(); - ExpressionContext *expression(); - - 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; - - }; - - IdInCollContext* idInColl(); - - class FunctionInvocationContext : public antlr4::ParserRuleContext { - public: - FunctionInvocationContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - FunctionNameContext *functionName(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - antlr4::tree::TerminalNode *DISTINCT(); - std::vector expression(); - ExpressionContext* expression(size_t i); - - 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; - - }; - - FunctionInvocationContext* functionInvocation(); - - class FunctionNameContext : public antlr4::ParserRuleContext { - public: - FunctionNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *UnescapedSymbolicName(); - antlr4::tree::TerminalNode *EscapedSymbolicName(); - antlr4::tree::TerminalNode *COUNT(); - - 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; - - }; - - FunctionNameContext* functionName(); - - class ListComprehensionContext : public antlr4::ParserRuleContext { - public: - ListComprehensionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - FilterExpressionContext *filterExpression(); - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - ExpressionContext *expression(); - - 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; - - }; - - 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(); - antlr4::tree::TerminalNode *SP(); - - 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; - - }; - - PropertyLookupContext* propertyLookup(); - - class VariableContext : public antlr4::ParserRuleContext { - public: - VariableContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - SymbolicNameContext *symbolicName(); - - 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; - - }; - - VariableContext* variable(); - - class NumberLiteralContext : public antlr4::ParserRuleContext { - public: - NumberLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - DoubleLiteralContext *doubleLiteral(); - IntegerLiteralContext *integerLiteral(); - - 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; - - }; - - NumberLiteralContext* numberLiteral(); - - class MapLiteralContext : public antlr4::ParserRuleContext { - public: - MapLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - std::vector SP(); - antlr4::tree::TerminalNode* SP(size_t i); - std::vector propertyKeyName(); - PropertyKeyNameContext* propertyKeyName(size_t i); - std::vector expression(); - ExpressionContext* expression(size_t i); - - 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; - - }; - - MapLiteralContext* mapLiteral(); - - class ParameterContext : public antlr4::ParserRuleContext { - public: - ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - SymbolicNameContext *symbolicName(); - antlr4::tree::TerminalNode *DecimalInteger(); - - 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; - - }; - - ParameterContext* parameter(); - - class PropertyExpressionContext : public antlr4::ParserRuleContext { - public: - PropertyExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - AtomContext *atom(); - std::vector propertyLookup(); - PropertyLookupContext* propertyLookup(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; - - virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; - - }; - - PropertyExpressionContext* propertyExpression(); - - class PropertyKeyNameContext : public antlr4::ParserRuleContext { - public: - PropertyKeyNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - SymbolicNameContext *symbolicName(); - - 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; - - }; - - PropertyKeyNameContext* propertyKeyName(); - - class IntegerLiteralContext : public antlr4::ParserRuleContext { - public: - IntegerLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *HexInteger(); - antlr4::tree::TerminalNode *OctalInteger(); - antlr4::tree::TerminalNode *DecimalInteger(); - - 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; - - }; - - IntegerLiteralContext* integerLiteral(); - - class DoubleLiteralContext : public antlr4::ParserRuleContext { - public: - DoubleLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *ExponentDecimalReal(); - antlr4::tree::TerminalNode *RegularDecimalReal(); - - 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; - - }; - - DoubleLiteralContext* doubleLiteral(); - - class SymbolicNameContext : public antlr4::ParserRuleContext { - public: - SymbolicNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - antlr4::tree::TerminalNode *UnescapedSymbolicName(); - antlr4::tree::TerminalNode *EscapedSymbolicName(); - antlr4::tree::TerminalNode *UNION(); - antlr4::tree::TerminalNode *ALL(); - antlr4::tree::TerminalNode *OPTIONAL(); - antlr4::tree::TerminalNode *MATCH(); - antlr4::tree::TerminalNode *UNWIND(); - antlr4::tree::TerminalNode *AS(); - antlr4::tree::TerminalNode *MERGE(); - antlr4::tree::TerminalNode *ON(); - antlr4::tree::TerminalNode *CREATE(); - antlr4::tree::TerminalNode *SET(); - antlr4::tree::TerminalNode *DETACH(); - antlr4::tree::TerminalNode *DELETE(); - antlr4::tree::TerminalNode *REMOVE(); - antlr4::tree::TerminalNode *WITH(); - antlr4::tree::TerminalNode *DISTINCT(); - antlr4::tree::TerminalNode *RETURN(); - antlr4::tree::TerminalNode *ORDER(); - antlr4::tree::TerminalNode *BY(); - antlr4::tree::TerminalNode *L_SKIP(); - antlr4::tree::TerminalNode *LIMIT(); - antlr4::tree::TerminalNode *ASCENDING(); - antlr4::tree::TerminalNode *ASC(); - antlr4::tree::TerminalNode *DESCENDING(); - antlr4::tree::TerminalNode *DESC(); - antlr4::tree::TerminalNode *WHERE(); - antlr4::tree::TerminalNode *OR(); - antlr4::tree::TerminalNode *XOR(); - antlr4::tree::TerminalNode *AND(); - antlr4::tree::TerminalNode *NOT(); - antlr4::tree::TerminalNode *IN(); - antlr4::tree::TerminalNode *STARTS(); - antlr4::tree::TerminalNode *ENDS(); - antlr4::tree::TerminalNode *CONTAINS(); - antlr4::tree::TerminalNode *IS(); - antlr4::tree::TerminalNode *CYPHERNULL(); - antlr4::tree::TerminalNode *COUNT(); - antlr4::tree::TerminalNode *FILTER(); - antlr4::tree::TerminalNode *EXTRACT(); - antlr4::tree::TerminalNode *ANY(); - antlr4::tree::TerminalNode *NONE(); - antlr4::tree::TerminalNode *SINGLE(); - antlr4::tree::TerminalNode *TRUE(); - antlr4::tree::TerminalNode *FALSE(); - antlr4::tree::TerminalNode *HexLetter(); - - 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; - - }; - - SymbolicNameContext* symbolicName(); - - class LeftArrowHeadContext : public antlr4::ParserRuleContext { - public: - LeftArrowHeadContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - - 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; - - }; - - LeftArrowHeadContext* leftArrowHead(); - - class RightArrowHeadContext : public antlr4::ParserRuleContext { - public: - RightArrowHeadContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - - 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; - - }; - - RightArrowHeadContext* rightArrowHead(); - - class DashContext : public antlr4::ParserRuleContext { - public: - DashContext(antlr4::ParserRuleContext *parent, size_t invokingState); - virtual size_t getRuleIndex() const override; - - 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; - - }; - - DashContext* dash(); - - -private: - static std::vector _decisionToDFA; - static antlr4::atn::PredictionContextCache _sharedContextCache; - static std::vector _ruleNames; - static std::vector _tokenNames; - - static std::vector _literalNames; - static std::vector _symbolicNames; - static antlr4::dfa::Vocabulary _vocabulary; - static antlr4::atn::ATN _atn; - static std::vector _serializedATN; - - - struct Initializer { - Initializer(); - }; - static Initializer _init; -}; - -} // namespace antlropencypher diff --git a/src/query/frontend/opencypher/generated/CypherVisitor.cpp b/src/query/frontend/opencypher/generated/CypherVisitor.cpp deleted file mode 100644 index 085ce56dd..000000000 --- a/src/query/frontend/opencypher/generated/CypherVisitor.cpp +++ /dev/null @@ -1,9 +0,0 @@ - -// 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 deleted file mode 100644 index 80936bedf..000000000 --- a/src/query/frontend/opencypher/generated/CypherVisitor.h +++ /dev/null @@ -1,186 +0,0 @@ - -// Generated from /home/mislav/code/memgraph/memgraph/src/query/frontend/opencypher/grammar/Cypher.g4 by ANTLR 4.6 - -#pragma once - - -#include "antlr4-runtime.h" -#include "CypherParser.h" - - -namespace antlropencypher { - -/** - * This class defines an abstract visitor for a parse tree - * produced by CypherParser. - */ -class CypherVisitor : public antlr4::tree::AbstractParseTreeVisitor { -public: - - /** - * Visit parse trees produced by CypherParser. - */ - virtual antlrcpp::Any visitCypher(CypherParser::CypherContext *context) = 0; - - virtual antlrcpp::Any visitStatement(CypherParser::StatementContext *context) = 0; - - virtual antlrcpp::Any visitQuery(CypherParser::QueryContext *context) = 0; - - virtual antlrcpp::Any visitRegularQuery(CypherParser::RegularQueryContext *context) = 0; - - virtual antlrcpp::Any visitSingleQuery(CypherParser::SingleQueryContext *context) = 0; - - virtual antlrcpp::Any visitCypherUnion(CypherParser::CypherUnionContext *context) = 0; - - virtual antlrcpp::Any visitClause(CypherParser::ClauseContext *context) = 0; - - virtual antlrcpp::Any visitCypherMatch(CypherParser::CypherMatchContext *context) = 0; - - virtual antlrcpp::Any visitUnwind(CypherParser::UnwindContext *context) = 0; - - virtual antlrcpp::Any visitMerge(CypherParser::MergeContext *context) = 0; - - virtual antlrcpp::Any visitMergeAction(CypherParser::MergeActionContext *context) = 0; - - virtual antlrcpp::Any visitCreate(CypherParser::CreateContext *context) = 0; - - virtual antlrcpp::Any visitSet(CypherParser::SetContext *context) = 0; - - virtual antlrcpp::Any visitSetItem(CypherParser::SetItemContext *context) = 0; - - virtual antlrcpp::Any visitCypherDelete(CypherParser::CypherDeleteContext *context) = 0; - - virtual antlrcpp::Any visitRemove(CypherParser::RemoveContext *context) = 0; - - virtual antlrcpp::Any visitRemoveItem(CypherParser::RemoveItemContext *context) = 0; - - virtual antlrcpp::Any visitWith(CypherParser::WithContext *context) = 0; - - virtual antlrcpp::Any visitCypherReturn(CypherParser::CypherReturnContext *context) = 0; - - virtual antlrcpp::Any visitReturnBody(CypherParser::ReturnBodyContext *context) = 0; - - virtual antlrcpp::Any visitReturnItems(CypherParser::ReturnItemsContext *context) = 0; - - virtual antlrcpp::Any visitReturnItem(CypherParser::ReturnItemContext *context) = 0; - - virtual antlrcpp::Any visitOrder(CypherParser::OrderContext *context) = 0; - - virtual antlrcpp::Any visitSkip(CypherParser::SkipContext *context) = 0; - - virtual antlrcpp::Any visitLimit(CypherParser::LimitContext *context) = 0; - - virtual antlrcpp::Any visitSortItem(CypherParser::SortItemContext *context) = 0; - - virtual antlrcpp::Any visitWhere(CypherParser::WhereContext *context) = 0; - - virtual antlrcpp::Any visitPattern(CypherParser::PatternContext *context) = 0; - - virtual antlrcpp::Any visitPatternPart(CypherParser::PatternPartContext *context) = 0; - - virtual antlrcpp::Any visitAnonymousPatternPart(CypherParser::AnonymousPatternPartContext *context) = 0; - - virtual antlrcpp::Any visitPatternElement(CypherParser::PatternElementContext *context) = 0; - - virtual antlrcpp::Any visitNodePattern(CypherParser::NodePatternContext *context) = 0; - - virtual antlrcpp::Any visitPatternElementChain(CypherParser::PatternElementChainContext *context) = 0; - - virtual antlrcpp::Any visitRelationshipPattern(CypherParser::RelationshipPatternContext *context) = 0; - - virtual antlrcpp::Any visitRelationshipDetail(CypherParser::RelationshipDetailContext *context) = 0; - - virtual antlrcpp::Any visitProperties(CypherParser::PropertiesContext *context) = 0; - - virtual antlrcpp::Any visitRelationshipTypes(CypherParser::RelationshipTypesContext *context) = 0; - - virtual antlrcpp::Any visitNodeLabels(CypherParser::NodeLabelsContext *context) = 0; - - virtual antlrcpp::Any visitNodeLabel(CypherParser::NodeLabelContext *context) = 0; - - virtual antlrcpp::Any visitRangeLiteral(CypherParser::RangeLiteralContext *context) = 0; - - virtual antlrcpp::Any visitLabelName(CypherParser::LabelNameContext *context) = 0; - - virtual antlrcpp::Any visitRelTypeName(CypherParser::RelTypeNameContext *context) = 0; - - virtual antlrcpp::Any visitExpression(CypherParser::ExpressionContext *context) = 0; - - virtual antlrcpp::Any visitExpression12(CypherParser::Expression12Context *context) = 0; - - virtual antlrcpp::Any visitExpression11(CypherParser::Expression11Context *context) = 0; - - virtual antlrcpp::Any visitExpression10(CypherParser::Expression10Context *context) = 0; - - virtual antlrcpp::Any visitExpression9(CypherParser::Expression9Context *context) = 0; - - virtual antlrcpp::Any visitExpression8(CypherParser::Expression8Context *context) = 0; - - virtual antlrcpp::Any visitExpression7(CypherParser::Expression7Context *context) = 0; - - virtual antlrcpp::Any visitExpression6(CypherParser::Expression6Context *context) = 0; - - virtual antlrcpp::Any visitExpression5(CypherParser::Expression5Context *context) = 0; - - virtual antlrcpp::Any visitExpression4(CypherParser::Expression4Context *context) = 0; - - virtual antlrcpp::Any visitExpression3(CypherParser::Expression3Context *context) = 0; - - virtual antlrcpp::Any visitExpression2(CypherParser::Expression2Context *context) = 0; - - virtual antlrcpp::Any visitAtom(CypherParser::AtomContext *context) = 0; - - virtual antlrcpp::Any visitLiteral(CypherParser::LiteralContext *context) = 0; - - virtual antlrcpp::Any visitBooleanLiteral(CypherParser::BooleanLiteralContext *context) = 0; - - virtual antlrcpp::Any visitListLiteral(CypherParser::ListLiteralContext *context) = 0; - - virtual antlrcpp::Any visitPartialComparisonExpression(CypherParser::PartialComparisonExpressionContext *context) = 0; - - virtual antlrcpp::Any visitParenthesizedExpression(CypherParser::ParenthesizedExpressionContext *context) = 0; - - virtual antlrcpp::Any visitRelationshipsPattern(CypherParser::RelationshipsPatternContext *context) = 0; - - virtual antlrcpp::Any visitFilterExpression(CypherParser::FilterExpressionContext *context) = 0; - - virtual antlrcpp::Any visitIdInColl(CypherParser::IdInCollContext *context) = 0; - - virtual antlrcpp::Any visitFunctionInvocation(CypherParser::FunctionInvocationContext *context) = 0; - - virtual antlrcpp::Any visitFunctionName(CypherParser::FunctionNameContext *context) = 0; - - 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; - - virtual antlrcpp::Any visitNumberLiteral(CypherParser::NumberLiteralContext *context) = 0; - - virtual antlrcpp::Any visitMapLiteral(CypherParser::MapLiteralContext *context) = 0; - - virtual antlrcpp::Any visitParameter(CypherParser::ParameterContext *context) = 0; - - virtual antlrcpp::Any visitPropertyExpression(CypherParser::PropertyExpressionContext *context) = 0; - - virtual antlrcpp::Any visitPropertyKeyName(CypherParser::PropertyKeyNameContext *context) = 0; - - virtual antlrcpp::Any visitIntegerLiteral(CypherParser::IntegerLiteralContext *context) = 0; - - virtual antlrcpp::Any visitDoubleLiteral(CypherParser::DoubleLiteralContext *context) = 0; - - virtual antlrcpp::Any visitSymbolicName(CypherParser::SymbolicNameContext *context) = 0; - - virtual antlrcpp::Any visitLeftArrowHead(CypherParser::LeftArrowHeadContext *context) = 0; - - virtual antlrcpp::Any visitRightArrowHead(CypherParser::RightArrowHeadContext *context) = 0; - - virtual antlrcpp::Any visitDash(CypherParser::DashContext *context) = 0; - - -}; - -} // namespace antlropencypher diff --git a/src/query/frontend/typecheck/typecheck.hpp b/src/query/frontend/typecheck/typecheck.hpp index 9923e6ee3..0014afc15 100644 --- a/src/query/frontend/typecheck/typecheck.hpp +++ b/src/query/frontend/typecheck/typecheck.hpp @@ -1,5 +1,7 @@ #pragma once +#include + #include "utils/exceptions/basic_exception.hpp" #include "query/frontend/ast/ast.hpp" #include "query/frontend/typecheck/symbol_table.hpp" @@ -19,6 +21,7 @@ class TypeCheckVisitor : public TreeVisitorBase { void Visit(NamedExpr& named_expr) override {} void Visit(Ident& ident) override { Symbol symbol; + std::cout << ident.identifier_ << std::endl; if (scope_.in_named_expr) { // TODO: Handle this better, so that the `with` variables aren't // shadowed. diff --git a/tests/manual/compiler_prototype.cpp b/tests/manual/compiler_prototype.cpp index 0763cacc1..256285809 100644 --- a/tests/manual/compiler_prototype.cpp +++ b/tests/manual/compiler_prototype.cpp @@ -27,6 +27,11 @@ int main(int argc, char* argv[]) { // initialize the database auto dba = dbms.active(); + // labels + auto company = dba.label("Company"); + auto person = dba.label("Person"); + auto device = dba.label("Device"); + // props auto name = dba.property("name"); auto age = dba.property("age"); @@ -35,18 +40,23 @@ int main(int argc, char* argv[]) { // vertices auto memgraph = dba.insert_vertex(); memgraph.PropsSet(name, "Memgraph"); + memgraph.add_label(company); auto teon = dba.insert_vertex(); memgraph.PropsSet(name, "Teon"); memgraph.PropsSet(age, 26); + teon.add_label(person); auto mislav = dba.insert_vertex(); memgraph.PropsSet(name, "Mislav"); memgraph.PropsSet(age, 22); + mislav.add_label(person); auto florijan = dba.insert_vertex(); memgraph.PropsSet(name, "Florijan"); memgraph.PropsSet(age, 31); + florijan.add_label(person); auto xps_15 = dba.insert_vertex(); memgraph.PropsSet(type, "PC"); memgraph.PropsSet(name, "Dell XPS 15"); + xps_15.add_label(device); // edges dba.insert_edge(teon, memgraph, dba.edge_type("MEMBER_OF")); @@ -66,6 +76,8 @@ int main(int argc, char* argv[]) { dba.insert_edge(mislav, xps_15, dba.edge_type("USES")); dba.insert_edge(florijan, xps_15, dba.edge_type("USES")); + dba.advance_command(); + cout << "-- Memgraph Query Engine --" << endl; while (true) { @@ -75,14 +87,15 @@ int main(int argc, char* argv[]) { std::getline(cin, command); if (command == "quit") break; // execute command / query - try { - auto db_accessor = dbms.active(); - query_engine.Execute(command, db_accessor, stream); - } catch (const std::exception& e) { - cout << e.what() << endl; - } catch (...) { - // pass - } + // try { + // auto db_accessor = dbms.active(); + query_engine.Execute(command, dba, stream); + // } catch (const std::exception& e) { + // cout << e.what() << endl; + // } catch (...) { + // // pass + // } +// } return 0;