From 0114bd1dc9e29f1049df84944caf1622572c3a3e Mon Sep 17 00:00:00 2001 From: Spade A <71589810+SpadeA-Tang@users.noreply.github.com> Date: Mon, 29 Dec 2025 11:03:26 +0800 Subject: [PATCH] feat: support match operator family (#46518) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit issue: https://github.com/milvus-io/milvus/issues/46517 ref: https://github.com/milvus-io/milvus/issues/42148 This PR supports match operator family with struct array and brute force search only. - Core invariant: match operators only target struct-array element-level predicates and assume callers provide a correct row_start so element indices form a contiguous range; IArrayOffsets implementations convert row-level bitmaps/rows (starting at row_start) into element-level bitmaps or a contiguous element-offset vector used by brute-force evaluation. - New capability added: end-to-end support for MATCH_* semantics (match_any, match_all, match_least, match_most, match_exact) — parser (grammar + proto), planner (ParseMatchExprs), expr model (expr::MatchExpr), compilation (Expr→PhyMatchFilterExpr), execution (PhyMatchFilterExpr::Eval uses element offsets/bitmaps), and unit tests (MatchExprTest + parser tests). Implementation currently works for struct-array inputs and uses brute-force element counting via RowBitsetToElementOffsets/RowBitsetToElementBitset. - Logic removed or simplified and why: removed the ad-hoc DocBitsetToElementOffsets helper and consolidated offset/bitset derivation into IArrayOffsets::RowBitsetToElementOffsets and a row_start-aware RowBitsetToElementBitset, and removed EvalCtx overloads that embedded ExprSet (now EvalCtx(exec_ctx, offset_input)). This centralizes array-layout logic in ArrayOffsets and removes duplicated offset conversion and EvalCtx variants that were redundant for element-level evaluation. - No data loss / no behavior regression: persistent formats are unchanged (no proto storage or on-disk layout changed); callers were updated to supply row_start and now route through the centralized ArrayOffsets APIs which still use the authoritative row_to_element_start_ mapping, preserving exact element index mappings. Eval logic changes are limited to in-memory plumbing (how offsets/bitmaps are produced and how EvalCtx is constructed); expression evaluation still invokes exprs_->Eval where needed, so existing behavior and stored data remain intact. --------- Signed-off-by: SpadeA Signed-off-by: SpadeA-Tang --- internal/core/src/common/ArrayOffsets.cpp | 128 +- internal/core/src/common/ArrayOffsets.h | 34 +- internal/core/src/common/ArrayOffsetsTest.cpp | 4 +- .../core/src/common/ElementFilterIterator.cpp | 2 +- internal/core/src/exec/expression/EvalCtx.h | 16 +- .../core/src/exec/expression/ExistsExpr.cpp | 10 +- internal/core/src/exec/expression/Expr.cpp | 12 + .../core/src/exec/expression/MatchExpr.cpp | 258 +++ internal/core/src/exec/expression/MatchExpr.h | 86 + .../src/exec/expression/MatchExprTest.cpp | 420 ++++ .../core/src/exec/expression/NullExpr.cpp | 6 +- .../exec/operator/ElementFilterBitsNode.cpp | 40 +- .../src/exec/operator/ElementFilterBitsNode.h | 3 - .../core/src/exec/operator/FilterBitsNode.cpp | 2 +- .../src/exec/operator/IterativeFilterNode.cpp | 5 +- .../core/src/exec/operator/RescoresNode.cpp | 2 +- .../src/exec/operator/VectorSearchNode.cpp | 2 +- internal/core/src/expr/ITypeExpr.h | 43 + internal/core/src/query/PlanProto.cpp | 36 +- internal/core/src/query/PlanProto.h | 3 + .../core/unittest/test_utils/GenExprProto.h | 3 +- internal/parser/planparserv2/Plan.g4 | 11 + .../planparserv2/fill_expression_value.go | 9 +- .../parser/planparserv2/generated/Plan.interp | 14 +- .../parser/planparserv2/generated/Plan.tokens | 134 +- .../planparserv2/generated/PlanLexer.interp | 20 +- .../planparserv2/generated/PlanLexer.tokens | 134 +- .../generated/plan_base_visitor.go | 20 + .../planparserv2/generated/plan_lexer.go | 1271 +++++------ .../planparserv2/generated/plan_parser.go | 1893 +++++++++++------ .../planparserv2/generated/plan_visitor.go | 15 + .../parser/planparserv2/parser_visitor.go | 131 +- .../planparserv2/plan_parser_v2_test.go | 147 ++ internal/parser/planparserv2/utils.go | 11 +- pkg/proto/plan.proto | 17 + pkg/proto/planpb/plan.pb.go | 1058 +++++---- 36 files changed, 4102 insertions(+), 1898 deletions(-) create mode 100644 internal/core/src/exec/expression/MatchExpr.cpp create mode 100644 internal/core/src/exec/expression/MatchExpr.h create mode 100644 internal/core/src/exec/expression/MatchExprTest.cpp diff --git a/internal/core/src/common/ArrayOffsets.cpp b/internal/core/src/common/ArrayOffsets.cpp index 8e9bdf1460..eb7daf94a6 100644 --- a/internal/core/src/common/ArrayOffsets.cpp +++ b/internal/core/src/common/ArrayOffsets.cpp @@ -46,25 +46,73 @@ ArrayOffsetsSealed::ElementIDRangeOfRow(int32_t row_id) const { std::pair ArrayOffsetsSealed::RowBitsetToElementBitset( const TargetBitmapView& row_bitset, - const TargetBitmapView& valid_row_bitset) const { - int64_t row_count = GetRowCount(); - int64_t element_count = GetTotalElementCount(); + const TargetBitmapView& valid_row_bitset, + int64_t row_start) const { + int64_t row_count = row_bitset.size(); + AssertInfo(row_start >= 0 && row_start + row_count <= GetRowCount(), + "row range out of bounds: row_start={}, row_count={}, " + "total_rows={}", + row_start, + row_count, + GetRowCount()); + + int64_t element_start = row_to_element_start_[row_start]; + int64_t element_end = row_to_element_start_[row_start + row_count]; + int64_t element_count = element_end - element_start; + TargetBitmap element_bitset(element_count); TargetBitmap valid_element_bitset(element_count); - for (int64_t row_id = 0; row_id < row_count; ++row_id) { - int64_t start = row_to_element_start_[row_id]; - int64_t end = row_to_element_start_[row_id + 1]; + for (int64_t i = 0; i < row_count; ++i) { + int64_t row_id = row_start + i; + int64_t start = row_to_element_start_[row_id] - element_start; + int64_t end = row_to_element_start_[row_id + 1] - element_start; if (start < end) { - element_bitset.set(start, end - start, row_bitset[row_id]); - valid_element_bitset.set( - start, end - start, valid_row_bitset[row_id]); + element_bitset.set(start, end - start, row_bitset[i]); + valid_element_bitset.set(start, end - start, valid_row_bitset[i]); } } return {std::move(element_bitset), std::move(valid_element_bitset)}; } +FixedVector +ArrayOffsetsSealed::RowBitsetToElementOffsets( + const TargetBitmapView& row_bitset, int64_t row_start) const { + int64_t row_count = row_bitset.size(); + AssertInfo(row_start >= 0 && row_start + row_count <= GetRowCount(), + "row range out of bounds: row_start={}, row_count={}, " + "total_rows={}", + row_start, + row_count, + GetRowCount()); + + int64_t selected_rows = row_bitset.count(); + FixedVector element_offsets; + if (selected_rows == 0) { + return element_offsets; + } + + int64_t avg_elem_per_row = + static_cast(element_row_ids_.size()) / + (static_cast(row_to_element_start_.size()) - 1); + + element_offsets.reserve(selected_rows * avg_elem_per_row); + + for (int64_t i = 0; i < row_count; ++i) { + if (row_bitset[i]) { + int64_t row_id = row_start + i; + int32_t first_elem = row_to_element_start_[row_id]; + int32_t last_elem = row_to_element_start_[row_id + 1]; + for (int32_t elem_id = first_elem; elem_id < last_elem; ++elem_id) { + element_offsets.push_back(elem_id); + } + } + } + + return element_offsets; +} + std::shared_ptr ArrayOffsetsSealed::BuildFromSegment(const void* segment, const FieldMeta& field_meta) { @@ -193,23 +241,73 @@ ArrayOffsetsGrowing::ElementIDRangeOfRow(int32_t row_id) const { std::pair ArrayOffsetsGrowing::RowBitsetToElementBitset( const TargetBitmapView& row_bitset, - const TargetBitmapView& valid_row_bitset) const { + const TargetBitmapView& valid_row_bitset, + int64_t row_start) const { std::shared_lock lock(mutex_); - int64_t element_count = element_row_ids_.size(); + int64_t row_count = row_bitset.size(); + AssertInfo(row_start >= 0 && row_start + row_count <= committed_row_count_, + "row range out of bounds: row_start={}, row_count={}, " + "committed_rows={}", + row_start, + row_count, + committed_row_count_); + + int64_t element_start = row_to_element_start_[row_start]; + int64_t element_end = row_to_element_start_[row_start + row_count]; + int64_t element_count = element_end - element_start; + TargetBitmap element_bitset(element_count); TargetBitmap valid_element_bitset(element_count); - // Direct access to element_row_ids_, no virtual function calls - for (size_t elem_id = 0; elem_id < element_row_ids_.size(); ++elem_id) { + for (int64_t elem_id = element_start; elem_id < element_end; ++elem_id) { auto row_id = element_row_ids_[elem_id]; - element_bitset[elem_id] = row_bitset[row_id]; - valid_element_bitset[elem_id] = valid_row_bitset[row_id]; + int64_t bitset_idx = row_id - row_start; + element_bitset[elem_id - element_start] = row_bitset[bitset_idx]; + valid_element_bitset[elem_id - element_start] = + valid_row_bitset[bitset_idx]; } return {std::move(element_bitset), std::move(valid_element_bitset)}; } +FixedVector +ArrayOffsetsGrowing::RowBitsetToElementOffsets( + const TargetBitmapView& row_bitset, int64_t row_start) const { + std::shared_lock lock(mutex_); + + int64_t row_count = row_bitset.size(); + AssertInfo(row_start >= 0 && row_start + row_count <= committed_row_count_, + "row range out of bounds: row_start={}, row_count={}, " + "committed_rows={}", + row_start, + row_count, + committed_row_count_); + + int64_t selected_rows = row_bitset.count(); + FixedVector element_offsets; + if (selected_rows == 0) { + return element_offsets; + } + int64_t avg_elem_per_row = + static_cast(element_row_ids_.size()) / + (static_cast(row_to_element_start_.size()) - 1); + element_offsets.reserve(selected_rows * avg_elem_per_row); + + for (int64_t i = 0; i < row_count; ++i) { + if (row_bitset[i]) { + int64_t row_id = row_start + i; + int32_t first_elem = row_to_element_start_[row_id]; + int32_t last_elem = row_to_element_start_[row_id + 1]; + for (int32_t elem_id = first_elem; elem_id < last_elem; ++elem_id) { + element_offsets.push_back(elem_id); + } + } + } + + return element_offsets; +} + void ArrayOffsetsGrowing::Insert(int64_t row_id_start, const int32_t* array_lengths, diff --git a/internal/core/src/common/ArrayOffsets.h b/internal/core/src/common/ArrayOffsets.h index 77ac98c53f..437b6c0ae4 100644 --- a/internal/core/src/common/ArrayOffsets.h +++ b/internal/core/src/common/ArrayOffsets.h @@ -50,10 +50,18 @@ class IArrayOffsets { ElementIDRangeOfRow(int32_t row_id) const = 0; // Convert row-level bitsets to element-level bitsets + // row_start: starting row index (0-based) + // row_bitset.size(): number of rows to process virtual std::pair - RowBitsetToElementBitset( - const TargetBitmapView& row_bitset, - const TargetBitmapView& valid_row_bitset) const = 0; + RowBitsetToElementBitset(const TargetBitmapView& row_bitset, + const TargetBitmapView& valid_row_bitset, + int64_t row_start) const = 0; + + // Convert row-level bitset to element offsets + // Returns element IDs for all rows where row_bitset[row_id] is true + virtual FixedVector + RowBitsetToElementOffsets(const TargetBitmapView& row_bitset, + int64_t row_start) const = 0; }; class ArrayOffsetsSealed : public IArrayOffsets { @@ -93,9 +101,13 @@ class ArrayOffsetsSealed : public IArrayOffsets { ElementIDRangeOfRow(int32_t row_id) const override; std::pair - RowBitsetToElementBitset( - const TargetBitmapView& row_bitset, - const TargetBitmapView& valid_row_bitset) const override; + RowBitsetToElementBitset(const TargetBitmapView& row_bitset, + const TargetBitmapView& valid_row_bitset, + int64_t row_start) const override; + + FixedVector + RowBitsetToElementOffsets(const TargetBitmapView& row_bitset, + int64_t row_start) const override; static std::shared_ptr BuildFromSegment(const void* segment, const FieldMeta& field_meta); @@ -132,9 +144,13 @@ class ArrayOffsetsGrowing : public IArrayOffsets { ElementIDRangeOfRow(int32_t row_id) const override; std::pair - RowBitsetToElementBitset( - const TargetBitmapView& row_bitset, - const TargetBitmapView& valid_row_bitset) const override; + RowBitsetToElementBitset(const TargetBitmapView& row_bitset, + const TargetBitmapView& valid_row_bitset, + int64_t row_start) const override; + + FixedVector + RowBitsetToElementOffsets(const TargetBitmapView& row_bitset, + int64_t row_start) const override; private: struct PendingRow { diff --git a/internal/core/src/common/ArrayOffsetsTest.cpp b/internal/core/src/common/ArrayOffsetsTest.cpp index 85792d8474..8badc092c0 100644 --- a/internal/core/src/common/ArrayOffsetsTest.cpp +++ b/internal/core/src/common/ArrayOffsetsTest.cpp @@ -114,7 +114,7 @@ TEST_F(ArrayOffsetsTest, SealedRowBitsetToElementBitset) { valid_row_bitset.size()); auto [elem_bitset, valid_elem_bitset] = - offsets.RowBitsetToElementBitset(row_view, valid_view); + offsets.RowBitsetToElementBitset(row_view, valid_view, 0); EXPECT_EQ(elem_bitset.size(), 6); // Elements of row 0 (elem 0, 1) should be true @@ -310,7 +310,7 @@ TEST_F(ArrayOffsetsTest, GrowingRowBitsetToElementBitset) { valid_row_bitset.size()); auto [elem_bitset, valid_elem_bitset] = - offsets.RowBitsetToElementBitset(row_view, valid_view); + offsets.RowBitsetToElementBitset(row_view, valid_view, 0); EXPECT_EQ(elem_bitset.size(), 6); EXPECT_TRUE(elem_bitset[0]); diff --git a/internal/core/src/common/ElementFilterIterator.cpp b/internal/core/src/common/ElementFilterIterator.cpp index a3005b812a..1af1c58510 100644 --- a/internal/core/src/common/ElementFilterIterator.cpp +++ b/internal/core/src/common/ElementFilterIterator.cpp @@ -79,7 +79,7 @@ ElementFilterIterator::FetchAndFilterBatch() { } // Step 2: Batch evaluate element-level expression - exec::EvalCtx eval_ctx(exec_context_, expr_set_, &element_ids_buffer_); + exec::EvalCtx eval_ctx(exec_context_, &element_ids_buffer_); std::vector results; // Evaluate the expression set (should contain only element_expr) diff --git a/internal/core/src/exec/expression/EvalCtx.h b/internal/core/src/exec/expression/EvalCtx.h index ab836c379e..9de63de7c0 100644 --- a/internal/core/src/exec/expression/EvalCtx.h +++ b/internal/core/src/exec/expression/EvalCtx.h @@ -27,23 +27,12 @@ namespace milvus { namespace exec { -class ExprSet; - using OffsetVector = FixedVector; class EvalCtx { public: - EvalCtx(ExecContext* exec_ctx, - ExprSet* expr_set, - OffsetVector* offset_input) - : exec_ctx_(exec_ctx), - expr_set_(expr_set), - offset_input_(offset_input) { + EvalCtx(ExecContext* exec_ctx, OffsetVector* offset_input) + : exec_ctx_(exec_ctx), offset_input_(offset_input) { assert(exec_ctx_ != nullptr); - assert(expr_set_ != nullptr); - } - - explicit EvalCtx(ExecContext* exec_ctx, ExprSet* expr_set) - : exec_ctx_(exec_ctx), expr_set_(expr_set) { } explicit EvalCtx(ExecContext* exec_ctx) : exec_ctx_(exec_ctx) { @@ -96,7 +85,6 @@ class EvalCtx { private: ExecContext* exec_ctx_ = nullptr; - ExprSet* expr_set_ = nullptr; // we may accept offsets array as input and do expr filtering on these data OffsetVector* offset_input_ = nullptr; bool input_no_nulls_ = false; diff --git a/internal/core/src/exec/expression/ExistsExpr.cpp b/internal/core/src/exec/expression/ExistsExpr.cpp index 377a59d020..af29224b7e 100644 --- a/internal/core/src/exec/expression/ExistsExpr.cpp +++ b/internal/core/src/exec/expression/ExistsExpr.cpp @@ -34,7 +34,11 @@ PhyExistsFilterExpr::Eval(EvalCtx& context, VectorPtr& result) { context.set_apply_valid_data_after_flip(false); auto input = context.get_offset_input(); SetHasOffsetInput((input != nullptr)); - switch (expr_->column_.data_type_) { + auto data_type = expr_->column_.data_type_; + if (expr_->column_.element_level_) { + data_type = expr_->column_.element_type_; + } + switch (data_type) { case DataType::JSON: { if (SegmentExpr::CanUseIndex() && !has_offset_input_) { result = EvalJsonExistsForIndex(); @@ -44,9 +48,7 @@ PhyExistsFilterExpr::Eval(EvalCtx& context, VectorPtr& result) { break; } default: - ThrowInfo(DataTypeInvalid, - "unsupported data type: {}", - expr_->column_.data_type_); + ThrowInfo(DataTypeInvalid, "unsupported data type: {}", data_type); } } diff --git a/internal/core/src/exec/expression/Expr.cpp b/internal/core/src/exec/expression/Expr.cpp index 15d7da1918..e824020823 100644 --- a/internal/core/src/exec/expression/Expr.cpp +++ b/internal/core/src/exec/expression/Expr.cpp @@ -30,6 +30,7 @@ #include "exec/expression/JsonContainsExpr.h" #include "exec/expression/LogicalBinaryExpr.h" #include "exec/expression/LogicalUnaryExpr.h" +#include "exec/expression/MatchExpr.h" #include "exec/expression/NullExpr.h" #include "exec/expression/TermExpr.h" #include "exec/expression/UnaryExpr.h" @@ -294,6 +295,17 @@ CompileExpression(const expr::TypedExprPtr& expr, context->get_active_count(), context->query_config()->get_expr_batch_size(), context->get_consistency_level()); + } else if (auto match_expr = + std::dynamic_pointer_cast( + expr)) { + result = std::make_shared( + compiled_inputs, + match_expr, + "PhyMatchFilterExpr", + op_ctx, + context->get_segment(), + context->get_active_count(), + context->query_config()->get_expr_batch_size()); } else { ThrowInfo(ExprInvalid, "unsupport expr: ", expr->ToString()); } diff --git a/internal/core/src/exec/expression/MatchExpr.cpp b/internal/core/src/exec/expression/MatchExpr.cpp new file mode 100644 index 0000000000..115f0165ac --- /dev/null +++ b/internal/core/src/exec/expression/MatchExpr.cpp @@ -0,0 +1,258 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "MatchExpr.h" +#include +#include +#include "common/Tracer.h" +#include "common/Types.h" + +namespace milvus { +namespace exec { + +using MatchType = milvus::expr::MatchType; + +template +void +ProcessMatchRows(int64_t row_count, + const IArrayOffsets* array_offsets, + const TargetBitmapView& match_bitset, + const TargetBitmapView& valid_bitset, + TargetBitmapView& result_bitset, + int64_t threshold) { + for (int64_t i = 0; i < row_count; ++i) { + auto [first_elem, last_elem] = array_offsets->ElementIDRangeOfRow(i); + int64_t hit_count = 0; + int64_t element_count = last_elem - first_elem; + bool early_fail = false; + + if constexpr (all_valid) { + for (auto j = first_elem; j < last_elem; ++j) { + bool matched = match_bitset[j]; + if (matched) { + ++hit_count; + } + + if constexpr (match_type == MatchType::MatchAny) { + if (hit_count > 0) { + break; + } + } else if constexpr (match_type == MatchType::MatchAll) { + if (!matched) { + early_fail = true; + break; + } + } else if constexpr (match_type == MatchType::MatchLeast) { + if (hit_count >= threshold) { + break; + } + } else if constexpr (match_type == MatchType::MatchMost || + match_type == MatchType::MatchExact) { + if (hit_count > threshold) { + early_fail = true; + break; + } + } + } + } else { + element_count = 0; + for (auto j = first_elem; j < last_elem; ++j) { + if (!valid_bitset[j]) { + continue; + } + ++element_count; + bool matched = match_bitset[j]; + if (matched) { + ++hit_count; + } + + if constexpr (match_type == MatchType::MatchAny) { + if (hit_count > 0) { + break; + } + } else if constexpr (match_type == MatchType::MatchAll) { + if (!matched) { + early_fail = true; + break; + } + } else if constexpr (match_type == MatchType::MatchLeast) { + if (hit_count >= threshold) { + break; + } + } else if constexpr (match_type == MatchType::MatchMost || + match_type == MatchType::MatchExact) { + if (hit_count > threshold) { + early_fail = true; + break; + } + } + } + } + + if (early_fail) { + continue; + } + + bool is_match = false; + if constexpr (match_type == MatchType::MatchAny) { + is_match = hit_count > 0; + } else if constexpr (match_type == MatchType::MatchAll) { + is_match = hit_count == element_count; + } else if constexpr (match_type == MatchType::MatchLeast) { + is_match = hit_count >= threshold; + } else if constexpr (match_type == MatchType::MatchMost) { + is_match = hit_count <= threshold; + } else if constexpr (match_type == MatchType::MatchExact) { + is_match = hit_count == threshold; + } + + if (is_match) { + result_bitset[i] = true; + } + } +} + +template +void +DispatchByValidity(bool all_valid, + int64_t row_count, + const IArrayOffsets* array_offsets, + const TargetBitmapView& match_bitset, + const TargetBitmapView& valid_bitset, + TargetBitmapView& result_bitset, + int64_t threshold) { + if (all_valid) { + ProcessMatchRows(row_count, + array_offsets, + match_bitset, + valid_bitset, + result_bitset, + threshold); + } else { + ProcessMatchRows(row_count, + array_offsets, + match_bitset, + valid_bitset, + result_bitset, + threshold); + } +} + +void +PhyMatchFilterExpr::Eval(EvalCtx& context, VectorPtr& result) { + tracer::AutoSpan span("PhyMatchFilterExpr::Eval", tracer::GetRootSpan()); + + auto input = context.get_offset_input(); + AssertInfo(input == nullptr, + "Offset input in match filter expr is not implemented now"); + + auto schema = segment_->get_schema(); + auto field_meta = + schema.GetFirstArrayFieldInStruct(expr_->get_struct_name()); + + auto array_offsets = segment_->GetArrayOffsets(field_meta.get_id()); + AssertInfo(array_offsets != nullptr, "Array offsets not available"); + + int64_t row_count = + context.get_exec_context()->get_query_context()->get_active_count(); + result = std::make_shared(TargetBitmap(row_count, false), + TargetBitmap(row_count, true)); + + auto col_vec = std::dynamic_pointer_cast(result); + AssertInfo(col_vec != nullptr, "Result should be ColumnVector"); + AssertInfo(col_vec->IsBitmap(), "Result should be bitmap"); + auto col_vec_size = col_vec->size(); + TargetBitmapView bitset_view(col_vec->GetRawData(), col_vec_size); + + auto [total_elements, _] = array_offsets->ElementIDRangeOfRow(row_count); + FixedVector element_offsets(total_elements); + std::iota(element_offsets.begin(), element_offsets.end(), 0); + + EvalCtx eval_ctx(context.get_exec_context(), &element_offsets); + + VectorPtr match_result; + // TODO(SpadeA): can be executed in batch + inputs_[0]->Eval(eval_ctx, match_result); + auto match_result_col_vec = + std::dynamic_pointer_cast(match_result); + AssertInfo(match_result_col_vec != nullptr, + "Match result should be ColumnVector"); + AssertInfo(match_result_col_vec->IsBitmap(), + "Match result should be bitmap"); + TargetBitmapView match_result_bitset_view( + match_result_col_vec->GetRawData(), match_result_col_vec->size()); + TargetBitmapView match_result_valid_view( + match_result_col_vec->GetValidRawData(), match_result_col_vec->size()); + + bool all_valid = match_result_valid_view.all(); + auto match_type = expr_->get_match_type(); + int64_t threshold = expr_->get_count(); + + switch (match_type) { + case MatchType::MatchAny: + DispatchByValidity(all_valid, + row_count, + array_offsets.get(), + match_result_bitset_view, + match_result_valid_view, + bitset_view, + threshold); + break; + case MatchType::MatchAll: + DispatchByValidity(all_valid, + row_count, + array_offsets.get(), + match_result_bitset_view, + match_result_valid_view, + bitset_view, + threshold); + break; + case MatchType::MatchLeast: + DispatchByValidity(all_valid, + row_count, + array_offsets.get(), + match_result_bitset_view, + match_result_valid_view, + bitset_view, + threshold); + break; + case MatchType::MatchMost: + DispatchByValidity(all_valid, + row_count, + array_offsets.get(), + match_result_bitset_view, + match_result_valid_view, + bitset_view, + threshold); + break; + case MatchType::MatchExact: + DispatchByValidity(all_valid, + row_count, + array_offsets.get(), + match_result_bitset_view, + match_result_valid_view, + bitset_view, + threshold); + break; + default: + ThrowInfo(OpTypeInvalid, + "Unsupported match type: {}", + static_cast(match_type)); + } +} + +} // namespace exec +} // namespace milvus diff --git a/internal/core/src/exec/expression/MatchExpr.h b/internal/core/src/exec/expression/MatchExpr.h new file mode 100644 index 0000000000..04e7956fee --- /dev/null +++ b/internal/core/src/exec/expression/MatchExpr.h @@ -0,0 +1,86 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include + +#include "common/EasyAssert.h" +#include "common/OpContext.h" +#include "common/Types.h" +#include "common/Vector.h" +#include "exec/expression/Expr.h" +#include "segcore/SegmentInterface.h" + +namespace milvus { +namespace exec { + +class PhyMatchFilterExpr : public Expr { + public: + PhyMatchFilterExpr( + const std::vector>& input, + const std::shared_ptr& expr, + const std::string& name, + milvus::OpContext* op_ctx, + const segcore::SegmentInternalInterface* segment, + int64_t active_count, + int64_t batch_size) + : Expr(DataType::BOOL, std::move(input), name, op_ctx), + expr_(expr), + segment_(segment), + active_count_(active_count), + batch_size_(batch_size) { + } + + void + Eval(EvalCtx& context, VectorPtr& result) override; + + void + MoveCursor() override { + if (!has_offset_input_) { + int64_t real_batch_size = + current_pos_ + batch_size_ >= active_count_ + ? active_count_ - current_pos_ + : batch_size_; + current_pos_ += real_batch_size; + } + } + + std::string + ToString() const override { + return fmt::format("{}", expr_->ToString()); + } + + bool + IsSource() const override { + return true; + } + + std::optional + GetColumnInfo() const override { + return std::nullopt; + } + + private: + std::shared_ptr expr_; + const segcore::SegmentInternalInterface* segment_; + int64_t active_count_; + int64_t current_pos_{0}; + int64_t batch_size_; +}; + +} // namespace exec +} // namespace milvus diff --git a/internal/core/src/exec/expression/MatchExprTest.cpp b/internal/core/src/exec/expression/MatchExprTest.cpp new file mode 100644 index 0000000000..021275e3e8 --- /dev/null +++ b/internal/core/src/exec/expression/MatchExprTest.cpp @@ -0,0 +1,420 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not +// use this file except in compliance with the License. You may obtain a copy of +// the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations under +// the License + +#include +#include +#include +#include + +#include "common/Schema.h" +#include "pb/plan.pb.h" +#include "query/Plan.h" +#include "segcore/SegmentGrowingImpl.h" +#include "test_utils/DataGen.h" + +using namespace milvus; +using namespace milvus::query; +using namespace milvus::segcore; + +class MatchExprTest : public ::testing::Test { + protected: + void + SetUp() override { + // Create schema with struct array sub-fields + schema_ = std::make_shared(); + vec_fid_ = schema_->AddDebugField( + "vec", DataType::VECTOR_FLOAT, 4, knowhere::metric::L2); + int64_fid_ = schema_->AddDebugField("id", DataType::INT64); + schema_->set_primary_field_id(int64_fid_); + + sub_str_fid_ = schema_->AddDebugArrayField( + "struct_array[sub_str]", DataType::VARCHAR, false); + sub_int_fid_ = schema_->AddDebugArrayField( + "struct_array[sub_int]", DataType::INT32, false); + + // Generate test data + GenerateTestData(); + + // Create and populate segment + seg_ = CreateGrowingSegment(schema_, empty_index_meta); + seg_->PreInsert(N_); + seg_->Insert( + 0, N_, row_ids_.data(), timestamps_.data(), insert_data_.get()); + } + + void + GenerateTestData() { + std::default_random_engine rng(42); + std::vector str_choices = {"aaa", "bbb", "ccc"}; + std::uniform_int_distribution<> str_dist(0, 2); + std::uniform_int_distribution<> int_dist(50, 150); + + insert_data_ = std::make_unique(); + + // Generate vector field + std::vector vec_data(N_ * 4); + std::normal_distribution vec_dist(0, 1); + for (auto& v : vec_data) { + v = vec_dist(rng); + } + auto vec_array = CreateDataArrayFrom( + vec_data.data(), nullptr, N_, schema_->operator[](vec_fid_)); + insert_data_->mutable_fields_data()->AddAllocated(vec_array.release()); + + // Generate id field + std::vector id_data(N_); + for (size_t i = 0; i < N_; ++i) { + id_data[i] = i; + } + auto id_array = CreateDataArrayFrom( + id_data.data(), nullptr, N_, schema_->operator[](int64_fid_)); + insert_data_->mutable_fields_data()->AddAllocated(id_array.release()); + + // Generate struct_array[sub_str] + sub_str_data_.resize(N_); + for (size_t i = 0; i < N_; ++i) { + for (int j = 0; j < array_len_; ++j) { + sub_str_data_[i].mutable_string_data()->add_data( + str_choices[str_dist(rng)]); + } + } + auto sub_str_array = + CreateDataArrayFrom(sub_str_data_.data(), + nullptr, + N_, + schema_->operator[](sub_str_fid_)); + insert_data_->mutable_fields_data()->AddAllocated( + sub_str_array.release()); + + // Generate struct_array[sub_int] + sub_int_data_.resize(N_); + for (size_t i = 0; i < N_; ++i) { + for (int j = 0; j < array_len_; ++j) { + sub_int_data_[i].mutable_int_data()->add_data(int_dist(rng)); + } + } + auto sub_int_array = + CreateDataArrayFrom(sub_int_data_.data(), + nullptr, + N_, + schema_->operator[](sub_int_fid_)); + insert_data_->mutable_fields_data()->AddAllocated( + sub_int_array.release()); + + insert_data_->set_num_rows(N_); + + // Generate row_ids and timestamps + row_ids_.resize(N_); + timestamps_.resize(N_); + for (size_t i = 0; i < N_; ++i) { + row_ids_[i] = i; + timestamps_[i] = i; + } + } + + // Count elements matching: sub_str == "aaa" && sub_int > 100 + int + CountMatchingElements(int64_t row_idx) const { + int count = 0; + const auto& str_field = sub_str_data_[row_idx]; + const auto& int_field = sub_int_data_[row_idx]; + for (int j = 0; j < array_len_; ++j) { + bool str_match = (str_field.string_data().data(j) == "aaa"); + bool int_match = (int_field.int_data().data(j) > 100); + if (str_match && int_match) { + ++count; + } + } + return count; + } + + // Create plan with specified match type and count + std::string + CreatePlanText(const std::string& match_type, int64_t count) { + return boost::str(boost::format(R"(vector_anns: < + field_id: %1% + predicates: < + match_expr: < + struct_name: "struct_array" + match_type: %4% + count: %5% + predicate: < + binary_expr: < + op: LogicalAnd + left: < + unary_range_expr: < + column_info: < + field_id: %2% + data_type: Array + element_type: VarChar + nested_path: "sub_str" + is_element_level: true + > + op: Equal + value: < + string_val: "aaa" + > + > + > + right: < + unary_range_expr: < + column_info: < + field_id: %3% + data_type: Array + element_type: Int32 + nested_path: "sub_int" + is_element_level: true + > + op: GreaterThan + value: < + int64_val: 100 + > + > + > + > + > + > + > + query_info: < + topk: 10 + round_decimal: 3 + metric_type: "L2" + search_params: "{\"nprobe\": 10}" + > + placeholder_tag: "$0" + >)") % vec_fid_.get() % + sub_str_fid_.get() % sub_int_fid_.get() % match_type % + count); + } + + // Execute search and return results + std::unique_ptr + ExecuteSearch(const std::string& raw_plan) { + proto::plan::PlanNode plan_node; + auto ok = + google::protobuf::TextFormat::ParseFromString(raw_plan, &plan_node); + EXPECT_TRUE(ok) << "Failed to parse plan"; + + auto plan = CreateSearchPlanFromPlanNode(schema_, plan_node); + EXPECT_NE(plan, nullptr); + + auto num_queries = 1; + auto ph_group_raw = CreatePlaceholderGroup(num_queries, 4, 1024); + auto ph_group = + ParsePlaceholderGroup(plan.get(), ph_group_raw.SerializeAsString()); + + return seg_->Search(plan.get(), ph_group.get(), 1L << 63); + } + + // Verify results based on match type + using VerifyFunc = std::function; + + void + VerifyResults(const SearchResult* result, + const std::string& match_type_name, + int64_t threshold, + VerifyFunc verify_func) { + std::cout << "=== " << match_type_name << " Results ===" << std::endl; + std::cout << "total_nq: " << result->total_nq_ << std::endl; + std::cout << "unity_topK: " << result->unity_topK_ << std::endl; + std::cout << "num_results: " << result->seg_offsets_.size() + << std::endl; + + for (int64_t i = 0; i < result->total_nq_; ++i) { + std::cout << "Query " << i << ":" << std::endl; + for (int64_t k = 0; k < result->unity_topK_; ++k) { + int64_t idx = i * result->unity_topK_ + k; + auto offset = result->seg_offsets_[idx]; + auto distance = result->distances_[idx]; + + std::cout << " [" << k << "] offset=" << offset + << ", distance=" << distance; + + if (offset >= 0 && offset < static_cast(N_)) { + // Print sub_str array + std::cout << ", sub_str=["; + const auto& str_field = sub_str_data_[offset]; + for (int j = 0; j < str_field.string_data().data_size(); + ++j) { + if (j > 0) + std::cout << ","; + std::cout << str_field.string_data().data(j); + } + std::cout << "]"; + + // Print sub_int array + std::cout << ", sub_int=["; + const auto& int_field = sub_int_data_[offset]; + for (int j = 0; j < int_field.int_data().data_size(); ++j) { + if (j > 0) + std::cout << ","; + std::cout << int_field.int_data().data(j); + } + std::cout << "]"; + + // Print match_count and verify + int match_count = CountMatchingElements(offset); + bool expected = + verify_func(match_count, array_len_, threshold); + std::cout << ", match_count=" << match_count; + + EXPECT_TRUE(expected) + << match_type_name << " failed for row " << offset + << ": match_count=" << match_count + << ", element_count=" << array_len_ + << ", threshold=" << threshold; + } + std::cout << std::endl; + } + } + std::cout << "==============================" << std::endl; + } + + // Member variables + std::shared_ptr schema_; + FieldId vec_fid_; + FieldId int64_fid_; + FieldId sub_str_fid_; + FieldId sub_int_fid_; + + std::unique_ptr insert_data_; + std::vector sub_str_data_; + std::vector sub_int_data_; + std::vector row_ids_; + std::vector timestamps_; + + SegmentGrowingPtr seg_; + + static constexpr size_t N_ = 1000; + static constexpr int array_len_ = 5; +}; + +TEST_F(MatchExprTest, MatchAny) { + auto raw_plan = CreatePlanText("MatchAny", 0); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchAny", + 0, + [](int match_count, int /*element_count*/, int64_t /*threshold*/) { + // MatchAny: at least one element matches + return match_count > 0; + }); +} + +TEST_F(MatchExprTest, MatchAll) { + auto raw_plan = CreatePlanText("MatchAll", 0); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchAll", + 0, + [](int match_count, int element_count, int64_t /*threshold*/) { + // MatchAll: all elements must match + return match_count == element_count; + }); +} + +TEST_F(MatchExprTest, MatchLeast) { + const int64_t threshold = 3; + auto raw_plan = CreatePlanText("MatchLeast", threshold); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchLeast(3)", + threshold, + [](int match_count, int /*element_count*/, int64_t threshold) { + // MatchLeast: at least N elements match + return match_count >= threshold; + }); +} + +TEST_F(MatchExprTest, MatchMost) { + const int64_t threshold = 2; + auto raw_plan = CreatePlanText("MatchMost", threshold); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchMost(2)", + threshold, + [](int match_count, int /*element_count*/, int64_t threshold) { + // MatchMost: at most N elements match + return match_count <= threshold; + }); +} + +TEST_F(MatchExprTest, MatchExact) { + const int64_t threshold = 2; + auto raw_plan = CreatePlanText("MatchExact", threshold); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchExact(2)", + threshold, + [](int match_count, int /*element_count*/, int64_t threshold) { + // MatchExact: exactly N elements match + return match_count == threshold; + }); +} + +// Edge case: MatchLeast with threshold = 1 (equivalent to MatchAny) +TEST_F(MatchExprTest, MatchLeastOne) { + const int64_t threshold = 1; + auto raw_plan = CreatePlanText("MatchLeast", threshold); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchLeast(1)", + threshold, + [](int match_count, int /*element_count*/, int64_t threshold) { + return match_count >= threshold; + }); +} + +// Edge case: MatchMost with threshold = 0 (no elements should match) +TEST_F(MatchExprTest, MatchMostZero) { + const int64_t threshold = 0; + auto raw_plan = CreatePlanText("MatchMost", threshold); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchMost(0)", + threshold, + [](int match_count, int /*element_count*/, int64_t threshold) { + return match_count <= threshold; + }); +} + +// Edge case: MatchExact with threshold = 0 (no elements should match) +TEST_F(MatchExprTest, MatchExactZero) { + const int64_t threshold = 0; + auto raw_plan = CreatePlanText("MatchExact", threshold); + auto result = ExecuteSearch(raw_plan); + + VerifyResults( + result.get(), + "MatchExact(0)", + threshold, + [](int match_count, int /*element_count*/, int64_t threshold) { + return match_count == threshold; + }); +} diff --git a/internal/core/src/exec/expression/NullExpr.cpp b/internal/core/src/exec/expression/NullExpr.cpp index e0f2dc5c6c..3d17953fec 100644 --- a/internal/core/src/exec/expression/NullExpr.cpp +++ b/internal/core/src/exec/expression/NullExpr.cpp @@ -31,7 +31,11 @@ PhyNullExpr::Eval(EvalCtx& context, VectorPtr& result) { static_cast(expr_->column_.data_type_)); auto input = context.get_offset_input(); - switch (expr_->column_.data_type_) { + auto data_type = expr_->column_.data_type_; + if (expr_->column_.element_level_) { + data_type = expr_->column_.element_type_; + } + switch (data_type) { case DataType::BOOL: { result = ExecVisitorImpl(input); break; diff --git a/internal/core/src/exec/operator/ElementFilterBitsNode.cpp b/internal/core/src/exec/operator/ElementFilterBitsNode.cpp index a686c68fd1..d31b296c56 100644 --- a/internal/core/src/exec/operator/ElementFilterBitsNode.cpp +++ b/internal/core/src/exec/operator/ElementFilterBitsNode.cpp @@ -88,7 +88,7 @@ PhyElementFilterBitsNode::GetOutput() { // Step 3: Convert doc bitset to element offsets FixedVector element_offsets = - DocBitsetToElementOffsets(doc_bitset); + array_offsets->RowBitsetToElementOffsets(doc_bitset, 0); // Step 4: Evaluate element expression auto [expr_result, valid_expr_result] = @@ -122,38 +122,6 @@ PhyElementFilterBitsNode::GetOutput() { return std::make_shared(col_res); } -FixedVector -PhyElementFilterBitsNode::DocBitsetToElementOffsets( - const TargetBitmapView& doc_bitset) { - auto array_offsets = query_context_->get_array_offsets(); - AssertInfo(array_offsets != nullptr, "Array offsets not available"); - - int64_t doc_count = array_offsets->GetRowCount(); - AssertInfo(doc_bitset.size() == doc_count, - "Doc bitset size mismatch: {} vs {}", - doc_bitset.size(), - doc_count); - - FixedVector element_offsets; - element_offsets.reserve(array_offsets->GetTotalElementCount()); - - // For each document that passes the filter, get all its element offsets - for (int64_t doc_id = 0; doc_id < doc_count; ++doc_id) { - if (doc_bitset[doc_id]) { - // Get element range for this document - auto [first_elem, last_elem] = - array_offsets->ElementIDRangeOfRow(doc_id); - - // Add all element IDs for this document - for (int64_t elem_id = first_elem; elem_id < last_elem; ++elem_id) { - element_offsets.push_back(static_cast(elem_id)); - } - } - } - - return element_offsets; -} - std::pair PhyElementFilterBitsNode::EvaluateElementExpression( FixedVector& element_offsets) { @@ -162,10 +130,8 @@ PhyElementFilterBitsNode::EvaluateElementExpression( true); tracer::AddEvent(fmt::format("input_elements: {}", element_offsets.size())); - // Use offset interface by passing element_offsets as third parameter - EvalCtx eval_ctx(operator_context_->get_exec_context(), - element_exprs_.get(), - &element_offsets); + // Use offset interface by passing element_offsets + EvalCtx eval_ctx(operator_context_->get_exec_context(), &element_offsets); std::vector results; element_exprs_->Eval(0, 1, true, eval_ctx, results); diff --git a/internal/core/src/exec/operator/ElementFilterBitsNode.h b/internal/core/src/exec/operator/ElementFilterBitsNode.h index d6dcf19ab2..f68b4a3967 100644 --- a/internal/core/src/exec/operator/ElementFilterBitsNode.h +++ b/internal/core/src/exec/operator/ElementFilterBitsNode.h @@ -77,9 +77,6 @@ class PhyElementFilterBitsNode : public Operator { } private: - FixedVector - DocBitsetToElementOffsets(const TargetBitmapView& doc_bitset); - std::pair EvaluateElementExpression(FixedVector& element_offsets); diff --git a/internal/core/src/exec/operator/FilterBitsNode.cpp b/internal/core/src/exec/operator/FilterBitsNode.cpp index bf43906ea0..ca189a3b13 100644 --- a/internal/core/src/exec/operator/FilterBitsNode.cpp +++ b/internal/core/src/exec/operator/FilterBitsNode.cpp @@ -74,7 +74,7 @@ PhyFilterBitsNode::GetOutput() { std::chrono::high_resolution_clock::time_point scalar_start = std::chrono::high_resolution_clock::now(); - EvalCtx eval_ctx(operator_context_->get_exec_context(), exprs_.get()); + EvalCtx eval_ctx(operator_context_->get_exec_context()); TargetBitmap bitset; TargetBitmap valid_bitset; diff --git a/internal/core/src/exec/operator/IterativeFilterNode.cpp b/internal/core/src/exec/operator/IterativeFilterNode.cpp index 1a329a7bc0..f49da5cd9d 100644 --- a/internal/core/src/exec/operator/IterativeFilterNode.cpp +++ b/internal/core/src/exec/operator/IterativeFilterNode.cpp @@ -160,7 +160,7 @@ PhyIterativeFilterNode::GetOutput() { TargetBitmap bitset; // get bitset of whole segment first if (!is_native_supported_) { - EvalCtx eval_ctx(operator_context_->get_exec_context(), exprs_.get()); + EvalCtx eval_ctx(operator_context_->get_exec_context()); TargetBitmap valid_bitset; while (num_processed_rows_ < need_process_rows_) { @@ -225,8 +225,7 @@ PhyIterativeFilterNode::GetOutput() { std::unordered_set unique_doc_ids; for (auto& iterator : search_result.vector_iterators_.value()) { - EvalCtx eval_ctx(operator_context_->get_exec_context(), - exprs_.get()); + EvalCtx eval_ctx(operator_context_->get_exec_context()); int topk = 0; while (iterator->HasNext() && topk < unity_topk) { FixedVector offsets; diff --git a/internal/core/src/exec/operator/RescoresNode.cpp b/internal/core/src/exec/operator/RescoresNode.cpp index 26138d8537..7bfb6c19b9 100644 --- a/internal/core/src/exec/operator/RescoresNode.cpp +++ b/internal/core/src/exec/operator/RescoresNode.cpp @@ -111,7 +111,7 @@ PhyRescoresNode::GetOutput() { filters.emplace_back(filter); auto expr_set = std::make_unique(filters, exec_context); std::vector results; - EvalCtx eval_ctx(exec_context, expr_set.get()); + EvalCtx eval_ctx(exec_context); const auto& exprs = expr_set->exprs(); bool is_native_supported = true; diff --git a/internal/core/src/exec/operator/VectorSearchNode.cpp b/internal/core/src/exec/operator/VectorSearchNode.cpp index ae1033bc1f..3b9bae35ca 100644 --- a/internal/core/src/exec/operator/VectorSearchNode.cpp +++ b/internal/core/src/exec/operator/VectorSearchNode.cpp @@ -104,7 +104,7 @@ PhyVectorSearchNode::GetOutput() { col_input->size()); auto [element_bitset, valid_element_bitset] = - array_offsets->RowBitsetToElementBitset(view, valid_view); + array_offsets->RowBitsetToElementBitset(view, valid_view, 0); query_context_->set_active_element_count(element_bitset.size()); diff --git a/internal/core/src/expr/ITypeExpr.h b/internal/core/src/expr/ITypeExpr.h index 27a7ddce62..0faf979bb8 100644 --- a/internal/core/src/expr/ITypeExpr.h +++ b/internal/core/src/expr/ITypeExpr.h @@ -890,6 +890,49 @@ class JsonContainsExpr : public ITypeFilterExpr { bool same_type_; const std::vector vals_; }; + +// MatchType mirrors the protobuf MatchType enum +using MatchType = proto::plan::MatchType; + +class MatchExpr : public ITypeFilterExpr { + public: + MatchExpr(const std::string& struct_name, + MatchType match_type, + int64_t count, + const TypedExprPtr& predicate) + : struct_name_(struct_name), match_type_(match_type), count_(count) { + inputs_.push_back(predicate); + } + + std::string + ToString() const override { + return fmt::format("MatchExpr(struct_name={}, match_type={}, count={})", + struct_name_, + proto::plan::MatchType_Name(match_type_), + count_); + } + + const std::string& + get_struct_name() const { + return struct_name_; + } + + MatchType + get_match_type() const { + return match_type_; + } + + int64_t + get_count() const { + return count_; + } + + private: + std::string struct_name_; + MatchType match_type_; + int64_t count_; // Used for MatchLeast/MatchMost/MatchExact +}; + } // namespace expr } // namespace milvus diff --git a/internal/core/src/query/PlanProto.cpp b/internal/core/src/query/PlanProto.cpp index f63259f633..a88c3b6957 100644 --- a/internal/core/src/query/PlanProto.cpp +++ b/internal/core/src/query/PlanProto.cpp @@ -445,7 +445,7 @@ ProtoParser::ParseUnaryRangeExprs(const proto::plan::UnaryRangeExpr& expr_pb) { if (column_info.is_element_level()) { Assert(data_type == DataType::ARRAY); Assert(field.get_element_type() == - static_cast(column_info.data_type())); + static_cast(column_info.element_type())); } else { Assert(data_type == static_cast(column_info.data_type())); } @@ -470,7 +470,7 @@ ProtoParser::ParseNullExprs(const proto::plan::NullExpr& expr_pb) { if (column_info.is_element_level()) { Assert(data_type == DataType::ARRAY); Assert(field.get_element_type() == - static_cast(column_info.data_type())); + static_cast(column_info.element_type())); } else { Assert(data_type == static_cast(column_info.data_type())); } @@ -488,7 +488,7 @@ ProtoParser::ParseBinaryRangeExprs( if (columnInfo.is_element_level()) { Assert(data_type == DataType::ARRAY); - Assert(field.get_element_type() == (DataType)columnInfo.data_type()); + Assert(field.get_element_type() == (DataType)columnInfo.element_type()); } else { Assert(data_type == (DataType)columnInfo.data_type()); } @@ -510,7 +510,7 @@ ProtoParser::ParseTimestamptzArithCompareExprs( if (columnInfo.is_element_level()) { Assert(data_type == DataType::ARRAY); - Assert(field.get_element_type() == (DataType)columnInfo.data_type()); + Assert(field.get_element_type() == (DataType)columnInfo.element_type()); } else { Assert(data_type == (DataType)columnInfo.data_type()); } @@ -533,6 +533,16 @@ ProtoParser::ParseElementFilterExprs( "ElementFilterExpr must be handled at PlanNode level."); } +expr::TypedExprPtr +ProtoParser::ParseMatchExprs(const proto::plan::MatchExpr& expr_pb) { + auto struct_name = expr_pb.struct_name(); + auto match_type = expr_pb.match_type(); + auto count = expr_pb.count(); + auto predicate = this->ParseExprs(expr_pb.predicate()); + return std::make_shared( + struct_name, match_type, count, predicate); +} + expr::TypedExprPtr ProtoParser::ParseCallExprs(const proto::plan::CallExpr& expr_pb) { std::vector parameters; @@ -566,7 +576,7 @@ ProtoParser::ParseCompareExprs(const proto::plan::CompareExpr& expr_pb) { if (left_column_info.is_element_level()) { Assert(left_data_type == DataType::ARRAY); Assert(left_field.get_element_type() == - static_cast(left_column_info.data_type())); + static_cast(left_column_info.element_type())); } else { Assert(left_data_type == static_cast(left_column_info.data_type())); @@ -580,7 +590,7 @@ ProtoParser::ParseCompareExprs(const proto::plan::CompareExpr& expr_pb) { if (right_column_info.is_element_level()) { Assert(right_data_type == DataType::ARRAY); Assert(right_field.get_element_type() == - static_cast(right_column_info.data_type())); + static_cast(right_column_info.element_type())); } else { Assert(right_data_type == static_cast(right_column_info.data_type())); @@ -602,7 +612,7 @@ ProtoParser::ParseTermExprs(const proto::plan::TermExpr& expr_pb) { if (columnInfo.is_element_level()) { Assert(data_type == DataType::ARRAY); - Assert(field.get_element_type() == (DataType)columnInfo.data_type()); + Assert(field.get_element_type() == (DataType)columnInfo.element_type()); } else { Assert(data_type == (DataType)columnInfo.data_type()); } @@ -641,7 +651,7 @@ ProtoParser::ParseBinaryArithOpEvalRangeExprs( if (column_info.is_element_level()) { Assert(data_type == DataType::ARRAY); Assert(field.get_element_type() == - static_cast(column_info.data_type())); + static_cast(column_info.element_type())); } else { Assert(data_type == static_cast(column_info.data_type())); } @@ -663,7 +673,7 @@ ProtoParser::ParseExistExprs(const proto::plan::ExistsExpr& expr_pb) { if (column_info.is_element_level()) { Assert(data_type == DataType::ARRAY); Assert(field.get_element_type() == - static_cast(column_info.data_type())); + static_cast(column_info.element_type())); } else { Assert(data_type == static_cast(column_info.data_type())); } @@ -680,7 +690,7 @@ ProtoParser::ParseJsonContainsExprs( if (columnInfo.is_element_level()) { Assert(data_type == DataType::ARRAY); - Assert(field.get_element_type() == (DataType)columnInfo.data_type()); + Assert(field.get_element_type() == (DataType)columnInfo.element_type()); } else { Assert(data_type == (DataType)columnInfo.data_type()); } @@ -715,7 +725,7 @@ ProtoParser::ParseGISFunctionFilterExprs( if (columnInfo.is_element_level()) { Assert(data_type == DataType::ARRAY); - Assert(field.get_element_type() == (DataType)columnInfo.data_type()); + Assert(field.get_element_type() == (DataType)columnInfo.element_type()); } else { Assert(data_type == (DataType)columnInfo.data_type()); } @@ -809,6 +819,10 @@ ProtoParser::ParseExprs(const proto::plan::Expr& expr_pb, "ElementFilterExpr should be handled at PlanNode level, " "not in ParseExprs"); } + case ppe::kMatchExpr: { + result = ParseMatchExprs(expr_pb.match_expr()); + break; + } default: { std::string s; google::protobuf::TextFormat::PrintToString(expr_pb, &s); diff --git a/internal/core/src/query/PlanProto.h b/internal/core/src/query/PlanProto.h index 7471c1e63b..9b04b66967 100644 --- a/internal/core/src/query/PlanProto.h +++ b/internal/core/src/query/PlanProto.h @@ -109,6 +109,9 @@ class ProtoParser { expr::TypedExprPtr ParseElementFilterExprs(const proto::plan::ElementFilterExpr& expr_pb); + expr::TypedExprPtr + ParseMatchExprs(const proto::plan::MatchExpr& expr_pb); + expr::TypedExprPtr ParseValueExprs(const proto::plan::ValueExpr& expr_pb); diff --git a/internal/core/unittest/test_utils/GenExprProto.h b/internal/core/unittest/test_utils/GenExprProto.h index a2c3a16a1a..e4e2b3e1fc 100644 --- a/internal/core/unittest/test_utils/GenExprProto.h +++ b/internal/core/unittest/test_utils/GenExprProto.h @@ -166,8 +166,7 @@ gen_filter_res(milvus::plan::PlanNode* plan_node, auto exprs_ = std::make_unique(filters, exec_context.get()); std::vector results_; - milvus::exec::EvalCtx eval_ctx(exec_context.get(), exprs_.get()); - eval_ctx.set_offset_input(offsets); + milvus::exec::EvalCtx eval_ctx(exec_context.get(), offsets); exprs_->Eval(0, 1, true, eval_ctx, results_); auto col_vec = std::dynamic_pointer_cast(results_[0]); diff --git a/internal/parser/planparserv2/Plan.g4 b/internal/parser/planparserv2/Plan.g4 index 0bfd2633db..9a680ac637 100644 --- a/internal/parser/planparserv2/Plan.g4 +++ b/internal/parser/planparserv2/Plan.g4 @@ -20,6 +20,11 @@ expr: | PHRASEMATCH'('Identifier',' StringLiteral (',' expr)? ')' # PhraseMatch | RANDOMSAMPLE'(' expr ')' # RandomSample | ElementFilter'('Identifier',' expr')' # ElementFilter + | MATCH_ALL'(' Identifier ',' expr ')' # MatchAll + | MATCH_ANY'(' Identifier ',' expr ')' # MatchAny + | MATCH_LEAST'(' Identifier ',' expr ',' THRESHOLD ASSIGN IntegerConstant ')' # MatchLeast + | MATCH_MOST'(' Identifier ',' expr ',' THRESHOLD ASSIGN IntegerConstant ')' # MatchMost + | MATCH_EXACT'(' Identifier ',' expr ',' THRESHOLD ASSIGN IntegerConstant ')' # MatchExact | expr POW expr # Power | op = (ADD | SUB | BNOT | NOT) expr # Unary // | '(' typeName ')' expr # Cast @@ -80,9 +85,15 @@ EXISTS: 'exists' | 'EXISTS'; TEXTMATCH: 'text_match'|'TEXT_MATCH'; PHRASEMATCH: 'phrase_match'|'PHRASE_MATCH'; RANDOMSAMPLE: 'random_sample' | 'RANDOM_SAMPLE'; +MATCH_ALL: 'match_all' | 'MATCH_ALL'; +MATCH_ANY: 'match_any' | 'MATCH_ANY'; +MATCH_LEAST: 'match_least' | 'MATCH_LEAST'; +MATCH_MOST: 'match_most' | 'MATCH_MOST'; +MATCH_EXACT: 'match_exact' | 'MATCH_EXACT'; INTERVAL: 'interval' | 'INTERVAL'; ISO: 'iso' | 'ISO'; MINIMUM_SHOULD_MATCH: 'minimum_should_match' | 'MINIMUM_SHOULD_MATCH'; +THRESHOLD: 'threshold' | 'THRESHOLD'; ASSIGN: '='; ADD: '+'; diff --git a/internal/parser/planparserv2/fill_expression_value.go b/internal/parser/planparserv2/fill_expression_value.go index 75a08fa0b8..1a87303aa2 100644 --- a/internal/parser/planparserv2/fill_expression_value.go +++ b/internal/parser/planparserv2/fill_expression_value.go @@ -64,7 +64,8 @@ func FillTermExpressionValue(expr *planpb.TermExpr, templateValues map[string]*p } dataType := expr.GetColumnInfo().GetDataType() if typeutil.IsArrayType(dataType) { - if len(expr.GetColumnInfo().GetNestedPath()) != 0 { + // Use element type if accessing array element + if len(expr.GetColumnInfo().GetNestedPath()) != 0 || expr.GetColumnInfo().GetIsElementLevel() { dataType = expr.GetColumnInfo().GetElementType() } } @@ -91,7 +92,8 @@ func FillUnaryRangeExpressionValue(expr *planpb.UnaryRangeExpr, templateValues m dataType := expr.GetColumnInfo().GetDataType() if typeutil.IsArrayType(dataType) { - if len(expr.GetColumnInfo().GetNestedPath()) != 0 { + // Use element type if accessing array element + if len(expr.GetColumnInfo().GetNestedPath()) != 0 || expr.GetColumnInfo().GetIsElementLevel() { dataType = expr.GetColumnInfo().GetElementType() } } @@ -107,7 +109,8 @@ func FillUnaryRangeExpressionValue(expr *planpb.UnaryRangeExpr, templateValues m func FillBinaryRangeExpressionValue(expr *planpb.BinaryRangeExpr, templateValues map[string]*planpb.GenericValue) error { var ok bool dataType := expr.GetColumnInfo().GetDataType() - if typeutil.IsArrayType(dataType) && len(expr.GetColumnInfo().GetNestedPath()) != 0 { + // Use element type if accessing array element + if typeutil.IsArrayType(dataType) && (len(expr.GetColumnInfo().GetNestedPath()) != 0 || expr.GetColumnInfo().GetIsElementLevel()) { dataType = expr.GetColumnInfo().GetElementType() } lowerValue := expr.GetLowerValue() diff --git a/internal/parser/planparserv2/generated/Plan.interp b/internal/parser/planparserv2/generated/Plan.interp index 6134d27abf..774b78c124 100644 --- a/internal/parser/planparserv2/generated/Plan.interp +++ b/internal/parser/planparserv2/generated/Plan.interp @@ -21,6 +21,12 @@ null null null null +null +null +null +null +null +null '=' '+' '-' @@ -89,9 +95,15 @@ EXISTS TEXTMATCH PHRASEMATCH RANDOMSAMPLE +MATCH_ALL +MATCH_ANY +MATCH_LEAST +MATCH_MOST +MATCH_EXACT INTERVAL ISO MINIMUM_SHOULD_MATCH +THRESHOLD ASSIGN ADD SUB @@ -146,4 +158,4 @@ textMatchOption atn: -[4, 1, 68, 252, 2, 0, 7, 0, 2, 1, 7, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 10, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 22, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 42, 8, 0, 10, 0, 12, 0, 45, 9, 0, 1, 0, 3, 0, 48, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 62, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 72, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 174, 8, 0, 10, 0, 12, 0, 177, 9, 0, 1, 0, 3, 0, 180, 8, 0, 3, 0, 182, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 189, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 205, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 243, 8, 0, 10, 0, 12, 0, 246, 9, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 2, 0, 2, 0, 15, 1, 0, 23, 24, 1, 0, 8, 13, 1, 0, 62, 63, 2, 0, 23, 24, 38, 39, 2, 0, 42, 42, 45, 45, 2, 0, 43, 43, 46, 46, 2, 0, 44, 44, 47, 47, 2, 0, 62, 62, 65, 65, 1, 0, 25, 27, 1, 0, 29, 30, 1, 0, 8, 9, 2, 0, 62, 62, 65, 66, 1, 0, 10, 11, 1, 0, 8, 11, 1, 0, 12, 13, 308, 0, 188, 1, 0, 0, 0, 2, 247, 1, 0, 0, 0, 4, 5, 6, 0, -1, 0, 5, 9, 5, 62, 0, 0, 6, 7, 7, 0, 0, 0, 7, 8, 5, 19, 0, 0, 8, 10, 5, 64, 0, 0, 9, 6, 1, 0, 0, 0, 9, 10, 1, 0, 0, 0, 10, 11, 1, 0, 0, 0, 11, 12, 7, 1, 0, 0, 12, 13, 5, 20, 0, 0, 13, 189, 5, 64, 0, 0, 14, 15, 5, 20, 0, 0, 15, 16, 5, 64, 0, 0, 16, 17, 7, 1, 0, 0, 17, 21, 5, 62, 0, 0, 18, 19, 7, 0, 0, 0, 19, 20, 5, 19, 0, 0, 20, 22, 5, 64, 0, 0, 21, 18, 1, 0, 0, 0, 21, 22, 1, 0, 0, 0, 22, 189, 1, 0, 0, 0, 23, 189, 5, 60, 0, 0, 24, 189, 5, 61, 0, 0, 25, 189, 5, 59, 0, 0, 26, 189, 5, 64, 0, 0, 27, 189, 7, 2, 0, 0, 28, 189, 5, 65, 0, 0, 29, 189, 5, 66, 0, 0, 30, 31, 5, 6, 0, 0, 31, 32, 5, 62, 0, 0, 32, 189, 5, 7, 0, 0, 33, 34, 5, 1, 0, 0, 34, 35, 3, 0, 0, 0, 35, 36, 5, 2, 0, 0, 36, 189, 1, 0, 0, 0, 37, 38, 5, 3, 0, 0, 38, 43, 3, 0, 0, 0, 39, 40, 5, 4, 0, 0, 40, 42, 3, 0, 0, 0, 41, 39, 1, 0, 0, 0, 42, 45, 1, 0, 0, 0, 43, 41, 1, 0, 0, 0, 43, 44, 1, 0, 0, 0, 44, 47, 1, 0, 0, 0, 45, 43, 1, 0, 0, 0, 46, 48, 5, 4, 0, 0, 47, 46, 1, 0, 0, 0, 47, 48, 1, 0, 0, 0, 48, 49, 1, 0, 0, 0, 49, 50, 5, 5, 0, 0, 50, 189, 1, 0, 0, 0, 51, 189, 5, 41, 0, 0, 52, 53, 5, 15, 0, 0, 53, 189, 3, 0, 0, 37, 54, 55, 5, 16, 0, 0, 55, 56, 5, 1, 0, 0, 56, 57, 5, 62, 0, 0, 57, 58, 5, 4, 0, 0, 58, 61, 5, 64, 0, 0, 59, 60, 5, 4, 0, 0, 60, 62, 3, 2, 1, 0, 61, 59, 1, 0, 0, 0, 61, 62, 1, 0, 0, 0, 62, 63, 1, 0, 0, 0, 63, 189, 5, 2, 0, 0, 64, 65, 5, 17, 0, 0, 65, 66, 5, 1, 0, 0, 66, 67, 5, 62, 0, 0, 67, 68, 5, 4, 0, 0, 68, 71, 5, 64, 0, 0, 69, 70, 5, 4, 0, 0, 70, 72, 3, 0, 0, 0, 71, 69, 1, 0, 0, 0, 71, 72, 1, 0, 0, 0, 72, 73, 1, 0, 0, 0, 73, 189, 5, 2, 0, 0, 74, 75, 5, 18, 0, 0, 75, 76, 5, 1, 0, 0, 76, 77, 3, 0, 0, 0, 77, 78, 5, 2, 0, 0, 78, 189, 1, 0, 0, 0, 79, 80, 5, 49, 0, 0, 80, 81, 5, 1, 0, 0, 81, 82, 5, 62, 0, 0, 82, 83, 5, 4, 0, 0, 83, 84, 3, 0, 0, 0, 84, 85, 5, 2, 0, 0, 85, 189, 1, 0, 0, 0, 86, 87, 7, 3, 0, 0, 87, 189, 3, 0, 0, 30, 88, 89, 7, 4, 0, 0, 89, 90, 5, 1, 0, 0, 90, 91, 3, 0, 0, 0, 91, 92, 5, 4, 0, 0, 92, 93, 3, 0, 0, 0, 93, 94, 5, 2, 0, 0, 94, 189, 1, 0, 0, 0, 95, 96, 7, 5, 0, 0, 96, 97, 5, 1, 0, 0, 97, 98, 3, 0, 0, 0, 98, 99, 5, 4, 0, 0, 99, 100, 3, 0, 0, 0, 100, 101, 5, 2, 0, 0, 101, 189, 1, 0, 0, 0, 102, 103, 7, 6, 0, 0, 103, 104, 5, 1, 0, 0, 104, 105, 3, 0, 0, 0, 105, 106, 5, 4, 0, 0, 106, 107, 3, 0, 0, 0, 107, 108, 5, 2, 0, 0, 108, 189, 1, 0, 0, 0, 109, 110, 5, 50, 0, 0, 110, 111, 5, 1, 0, 0, 111, 112, 5, 62, 0, 0, 112, 113, 5, 4, 0, 0, 113, 114, 5, 64, 0, 0, 114, 189, 5, 2, 0, 0, 115, 116, 5, 51, 0, 0, 116, 117, 5, 1, 0, 0, 117, 118, 5, 62, 0, 0, 118, 119, 5, 4, 0, 0, 119, 120, 5, 64, 0, 0, 120, 189, 5, 2, 0, 0, 121, 122, 5, 52, 0, 0, 122, 123, 5, 1, 0, 0, 123, 124, 5, 62, 0, 0, 124, 125, 5, 4, 0, 0, 125, 126, 5, 64, 0, 0, 126, 189, 5, 2, 0, 0, 127, 128, 5, 53, 0, 0, 128, 129, 5, 1, 0, 0, 129, 130, 5, 62, 0, 0, 130, 131, 5, 4, 0, 0, 131, 132, 5, 64, 0, 0, 132, 189, 5, 2, 0, 0, 133, 134, 5, 54, 0, 0, 134, 135, 5, 1, 0, 0, 135, 136, 5, 62, 0, 0, 136, 137, 5, 4, 0, 0, 137, 138, 5, 64, 0, 0, 138, 189, 5, 2, 0, 0, 139, 140, 5, 55, 0, 0, 140, 141, 5, 1, 0, 0, 141, 142, 5, 62, 0, 0, 142, 143, 5, 4, 0, 0, 143, 144, 5, 64, 0, 0, 144, 189, 5, 2, 0, 0, 145, 146, 5, 56, 0, 0, 146, 147, 5, 1, 0, 0, 147, 148, 5, 62, 0, 0, 148, 149, 5, 4, 0, 0, 149, 150, 5, 64, 0, 0, 150, 189, 5, 2, 0, 0, 151, 152, 5, 57, 0, 0, 152, 153, 5, 1, 0, 0, 153, 154, 5, 62, 0, 0, 154, 155, 5, 4, 0, 0, 155, 156, 5, 64, 0, 0, 156, 157, 5, 4, 0, 0, 157, 158, 3, 0, 0, 0, 158, 159, 5, 2, 0, 0, 159, 189, 1, 0, 0, 0, 160, 161, 5, 58, 0, 0, 161, 162, 5, 1, 0, 0, 162, 163, 5, 62, 0, 0, 163, 189, 5, 2, 0, 0, 164, 165, 5, 48, 0, 0, 165, 166, 5, 1, 0, 0, 166, 167, 7, 7, 0, 0, 167, 189, 5, 2, 0, 0, 168, 169, 5, 62, 0, 0, 169, 181, 5, 1, 0, 0, 170, 175, 3, 0, 0, 0, 171, 172, 5, 4, 0, 0, 172, 174, 3, 0, 0, 0, 173, 171, 1, 0, 0, 0, 174, 177, 1, 0, 0, 0, 175, 173, 1, 0, 0, 0, 175, 176, 1, 0, 0, 0, 176, 179, 1, 0, 0, 0, 177, 175, 1, 0, 0, 0, 178, 180, 5, 4, 0, 0, 179, 178, 1, 0, 0, 0, 179, 180, 1, 0, 0, 0, 180, 182, 1, 0, 0, 0, 181, 170, 1, 0, 0, 0, 181, 182, 1, 0, 0, 0, 182, 183, 1, 0, 0, 0, 183, 189, 5, 2, 0, 0, 184, 185, 7, 7, 0, 0, 185, 189, 5, 36, 0, 0, 186, 187, 7, 7, 0, 0, 187, 189, 5, 37, 0, 0, 188, 4, 1, 0, 0, 0, 188, 14, 1, 0, 0, 0, 188, 23, 1, 0, 0, 0, 188, 24, 1, 0, 0, 0, 188, 25, 1, 0, 0, 0, 188, 26, 1, 0, 0, 0, 188, 27, 1, 0, 0, 0, 188, 28, 1, 0, 0, 0, 188, 29, 1, 0, 0, 0, 188, 30, 1, 0, 0, 0, 188, 33, 1, 0, 0, 0, 188, 37, 1, 0, 0, 0, 188, 51, 1, 0, 0, 0, 188, 52, 1, 0, 0, 0, 188, 54, 1, 0, 0, 0, 188, 64, 1, 0, 0, 0, 188, 74, 1, 0, 0, 0, 188, 79, 1, 0, 0, 0, 188, 86, 1, 0, 0, 0, 188, 88, 1, 0, 0, 0, 188, 95, 1, 0, 0, 0, 188, 102, 1, 0, 0, 0, 188, 109, 1, 0, 0, 0, 188, 115, 1, 0, 0, 0, 188, 121, 1, 0, 0, 0, 188, 127, 1, 0, 0, 0, 188, 133, 1, 0, 0, 0, 188, 139, 1, 0, 0, 0, 188, 145, 1, 0, 0, 0, 188, 151, 1, 0, 0, 0, 188, 160, 1, 0, 0, 0, 188, 164, 1, 0, 0, 0, 188, 168, 1, 0, 0, 0, 188, 184, 1, 0, 0, 0, 188, 186, 1, 0, 0, 0, 189, 244, 1, 0, 0, 0, 190, 191, 10, 31, 0, 0, 191, 192, 5, 28, 0, 0, 192, 243, 3, 0, 0, 32, 193, 194, 10, 29, 0, 0, 194, 195, 7, 8, 0, 0, 195, 243, 3, 0, 0, 30, 196, 197, 10, 28, 0, 0, 197, 198, 7, 0, 0, 0, 198, 243, 3, 0, 0, 29, 199, 200, 10, 27, 0, 0, 200, 201, 7, 9, 0, 0, 201, 243, 3, 0, 0, 28, 202, 204, 10, 26, 0, 0, 203, 205, 5, 39, 0, 0, 204, 203, 1, 0, 0, 0, 204, 205, 1, 0, 0, 0, 205, 206, 1, 0, 0, 0, 206, 207, 5, 40, 0, 0, 207, 243, 3, 0, 0, 27, 208, 209, 10, 11, 0, 0, 209, 210, 7, 10, 0, 0, 210, 211, 7, 11, 0, 0, 211, 212, 7, 10, 0, 0, 212, 243, 3, 0, 0, 12, 213, 214, 10, 10, 0, 0, 214, 215, 7, 12, 0, 0, 215, 216, 7, 11, 0, 0, 216, 217, 7, 12, 0, 0, 217, 243, 3, 0, 0, 11, 218, 219, 10, 9, 0, 0, 219, 220, 7, 13, 0, 0, 220, 243, 3, 0, 0, 10, 221, 222, 10, 8, 0, 0, 222, 223, 7, 14, 0, 0, 223, 243, 3, 0, 0, 9, 224, 225, 10, 7, 0, 0, 225, 226, 5, 31, 0, 0, 226, 243, 3, 0, 0, 8, 227, 228, 10, 6, 0, 0, 228, 229, 5, 33, 0, 0, 229, 243, 3, 0, 0, 7, 230, 231, 10, 5, 0, 0, 231, 232, 5, 32, 0, 0, 232, 243, 3, 0, 0, 6, 233, 234, 10, 4, 0, 0, 234, 235, 5, 34, 0, 0, 235, 243, 3, 0, 0, 5, 236, 237, 10, 3, 0, 0, 237, 238, 5, 35, 0, 0, 238, 243, 3, 0, 0, 4, 239, 240, 10, 36, 0, 0, 240, 241, 5, 14, 0, 0, 241, 243, 5, 64, 0, 0, 242, 190, 1, 0, 0, 0, 242, 193, 1, 0, 0, 0, 242, 196, 1, 0, 0, 0, 242, 199, 1, 0, 0, 0, 242, 202, 1, 0, 0, 0, 242, 208, 1, 0, 0, 0, 242, 213, 1, 0, 0, 0, 242, 218, 1, 0, 0, 0, 242, 221, 1, 0, 0, 0, 242, 224, 1, 0, 0, 0, 242, 227, 1, 0, 0, 0, 242, 230, 1, 0, 0, 0, 242, 233, 1, 0, 0, 0, 242, 236, 1, 0, 0, 0, 242, 239, 1, 0, 0, 0, 243, 246, 1, 0, 0, 0, 244, 242, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245, 1, 1, 0, 0, 0, 246, 244, 1, 0, 0, 0, 247, 248, 5, 21, 0, 0, 248, 249, 5, 22, 0, 0, 249, 250, 5, 60, 0, 0, 250, 3, 1, 0, 0, 0, 13, 9, 21, 43, 47, 61, 71, 175, 179, 181, 188, 204, 242, 244] \ No newline at end of file +[4, 1, 74, 299, 2, 0, 7, 0, 2, 1, 7, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 10, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 22, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 42, 8, 0, 10, 0, 12, 0, 45, 9, 0, 1, 0, 3, 0, 48, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 62, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 72, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 221, 8, 0, 10, 0, 12, 0, 224, 9, 0, 1, 0, 3, 0, 227, 8, 0, 3, 0, 229, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 236, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 252, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 290, 8, 0, 10, 0, 12, 0, 293, 9, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 2, 0, 2, 0, 15, 1, 0, 29, 30, 1, 0, 8, 13, 1, 0, 68, 69, 2, 0, 29, 30, 44, 45, 2, 0, 48, 48, 51, 51, 2, 0, 49, 49, 52, 52, 2, 0, 50, 50, 53, 53, 2, 0, 68, 68, 71, 71, 1, 0, 31, 33, 1, 0, 35, 36, 1, 0, 8, 9, 2, 0, 68, 68, 71, 72, 1, 0, 10, 11, 1, 0, 8, 11, 1, 0, 12, 13, 360, 0, 235, 1, 0, 0, 0, 2, 294, 1, 0, 0, 0, 4, 5, 6, 0, -1, 0, 5, 9, 5, 68, 0, 0, 6, 7, 7, 0, 0, 0, 7, 8, 5, 24, 0, 0, 8, 10, 5, 70, 0, 0, 9, 6, 1, 0, 0, 0, 9, 10, 1, 0, 0, 0, 10, 11, 1, 0, 0, 0, 11, 12, 7, 1, 0, 0, 12, 13, 5, 25, 0, 0, 13, 236, 5, 70, 0, 0, 14, 15, 5, 25, 0, 0, 15, 16, 5, 70, 0, 0, 16, 17, 7, 1, 0, 0, 17, 21, 5, 68, 0, 0, 18, 19, 7, 0, 0, 0, 19, 20, 5, 24, 0, 0, 20, 22, 5, 70, 0, 0, 21, 18, 1, 0, 0, 0, 21, 22, 1, 0, 0, 0, 22, 236, 1, 0, 0, 0, 23, 236, 5, 66, 0, 0, 24, 236, 5, 67, 0, 0, 25, 236, 5, 65, 0, 0, 26, 236, 5, 70, 0, 0, 27, 236, 7, 2, 0, 0, 28, 236, 5, 71, 0, 0, 29, 236, 5, 72, 0, 0, 30, 31, 5, 6, 0, 0, 31, 32, 5, 68, 0, 0, 32, 236, 5, 7, 0, 0, 33, 34, 5, 1, 0, 0, 34, 35, 3, 0, 0, 0, 35, 36, 5, 2, 0, 0, 36, 236, 1, 0, 0, 0, 37, 38, 5, 3, 0, 0, 38, 43, 3, 0, 0, 0, 39, 40, 5, 4, 0, 0, 40, 42, 3, 0, 0, 0, 41, 39, 1, 0, 0, 0, 42, 45, 1, 0, 0, 0, 43, 41, 1, 0, 0, 0, 43, 44, 1, 0, 0, 0, 44, 47, 1, 0, 0, 0, 45, 43, 1, 0, 0, 0, 46, 48, 5, 4, 0, 0, 47, 46, 1, 0, 0, 0, 47, 48, 1, 0, 0, 0, 48, 49, 1, 0, 0, 0, 49, 50, 5, 5, 0, 0, 50, 236, 1, 0, 0, 0, 51, 236, 5, 47, 0, 0, 52, 53, 5, 15, 0, 0, 53, 236, 3, 0, 0, 42, 54, 55, 5, 16, 0, 0, 55, 56, 5, 1, 0, 0, 56, 57, 5, 68, 0, 0, 57, 58, 5, 4, 0, 0, 58, 61, 5, 70, 0, 0, 59, 60, 5, 4, 0, 0, 60, 62, 3, 2, 1, 0, 61, 59, 1, 0, 0, 0, 61, 62, 1, 0, 0, 0, 62, 63, 1, 0, 0, 0, 63, 236, 5, 2, 0, 0, 64, 65, 5, 17, 0, 0, 65, 66, 5, 1, 0, 0, 66, 67, 5, 68, 0, 0, 67, 68, 5, 4, 0, 0, 68, 71, 5, 70, 0, 0, 69, 70, 5, 4, 0, 0, 70, 72, 3, 0, 0, 0, 71, 69, 1, 0, 0, 0, 71, 72, 1, 0, 0, 0, 72, 73, 1, 0, 0, 0, 73, 236, 5, 2, 0, 0, 74, 75, 5, 18, 0, 0, 75, 76, 5, 1, 0, 0, 76, 77, 3, 0, 0, 0, 77, 78, 5, 2, 0, 0, 78, 236, 1, 0, 0, 0, 79, 80, 5, 55, 0, 0, 80, 81, 5, 1, 0, 0, 81, 82, 5, 68, 0, 0, 82, 83, 5, 4, 0, 0, 83, 84, 3, 0, 0, 0, 84, 85, 5, 2, 0, 0, 85, 236, 1, 0, 0, 0, 86, 87, 5, 19, 0, 0, 87, 88, 5, 1, 0, 0, 88, 89, 5, 68, 0, 0, 89, 90, 5, 4, 0, 0, 90, 91, 3, 0, 0, 0, 91, 92, 5, 2, 0, 0, 92, 236, 1, 0, 0, 0, 93, 94, 5, 20, 0, 0, 94, 95, 5, 1, 0, 0, 95, 96, 5, 68, 0, 0, 96, 97, 5, 4, 0, 0, 97, 98, 3, 0, 0, 0, 98, 99, 5, 2, 0, 0, 99, 236, 1, 0, 0, 0, 100, 101, 5, 21, 0, 0, 101, 102, 5, 1, 0, 0, 102, 103, 5, 68, 0, 0, 103, 104, 5, 4, 0, 0, 104, 105, 3, 0, 0, 0, 105, 106, 5, 4, 0, 0, 106, 107, 5, 27, 0, 0, 107, 108, 5, 28, 0, 0, 108, 109, 5, 66, 0, 0, 109, 110, 5, 2, 0, 0, 110, 236, 1, 0, 0, 0, 111, 112, 5, 22, 0, 0, 112, 113, 5, 1, 0, 0, 113, 114, 5, 68, 0, 0, 114, 115, 5, 4, 0, 0, 115, 116, 3, 0, 0, 0, 116, 117, 5, 4, 0, 0, 117, 118, 5, 27, 0, 0, 118, 119, 5, 28, 0, 0, 119, 120, 5, 66, 0, 0, 120, 121, 5, 2, 0, 0, 121, 236, 1, 0, 0, 0, 122, 123, 5, 23, 0, 0, 123, 124, 5, 1, 0, 0, 124, 125, 5, 68, 0, 0, 125, 126, 5, 4, 0, 0, 126, 127, 3, 0, 0, 0, 127, 128, 5, 4, 0, 0, 128, 129, 5, 27, 0, 0, 129, 130, 5, 28, 0, 0, 130, 131, 5, 66, 0, 0, 131, 132, 5, 2, 0, 0, 132, 236, 1, 0, 0, 0, 133, 134, 7, 3, 0, 0, 134, 236, 3, 0, 0, 30, 135, 136, 7, 4, 0, 0, 136, 137, 5, 1, 0, 0, 137, 138, 3, 0, 0, 0, 138, 139, 5, 4, 0, 0, 139, 140, 3, 0, 0, 0, 140, 141, 5, 2, 0, 0, 141, 236, 1, 0, 0, 0, 142, 143, 7, 5, 0, 0, 143, 144, 5, 1, 0, 0, 144, 145, 3, 0, 0, 0, 145, 146, 5, 4, 0, 0, 146, 147, 3, 0, 0, 0, 147, 148, 5, 2, 0, 0, 148, 236, 1, 0, 0, 0, 149, 150, 7, 6, 0, 0, 150, 151, 5, 1, 0, 0, 151, 152, 3, 0, 0, 0, 152, 153, 5, 4, 0, 0, 153, 154, 3, 0, 0, 0, 154, 155, 5, 2, 0, 0, 155, 236, 1, 0, 0, 0, 156, 157, 5, 56, 0, 0, 157, 158, 5, 1, 0, 0, 158, 159, 5, 68, 0, 0, 159, 160, 5, 4, 0, 0, 160, 161, 5, 70, 0, 0, 161, 236, 5, 2, 0, 0, 162, 163, 5, 57, 0, 0, 163, 164, 5, 1, 0, 0, 164, 165, 5, 68, 0, 0, 165, 166, 5, 4, 0, 0, 166, 167, 5, 70, 0, 0, 167, 236, 5, 2, 0, 0, 168, 169, 5, 58, 0, 0, 169, 170, 5, 1, 0, 0, 170, 171, 5, 68, 0, 0, 171, 172, 5, 4, 0, 0, 172, 173, 5, 70, 0, 0, 173, 236, 5, 2, 0, 0, 174, 175, 5, 59, 0, 0, 175, 176, 5, 1, 0, 0, 176, 177, 5, 68, 0, 0, 177, 178, 5, 4, 0, 0, 178, 179, 5, 70, 0, 0, 179, 236, 5, 2, 0, 0, 180, 181, 5, 60, 0, 0, 181, 182, 5, 1, 0, 0, 182, 183, 5, 68, 0, 0, 183, 184, 5, 4, 0, 0, 184, 185, 5, 70, 0, 0, 185, 236, 5, 2, 0, 0, 186, 187, 5, 61, 0, 0, 187, 188, 5, 1, 0, 0, 188, 189, 5, 68, 0, 0, 189, 190, 5, 4, 0, 0, 190, 191, 5, 70, 0, 0, 191, 236, 5, 2, 0, 0, 192, 193, 5, 62, 0, 0, 193, 194, 5, 1, 0, 0, 194, 195, 5, 68, 0, 0, 195, 196, 5, 4, 0, 0, 196, 197, 5, 70, 0, 0, 197, 236, 5, 2, 0, 0, 198, 199, 5, 63, 0, 0, 199, 200, 5, 1, 0, 0, 200, 201, 5, 68, 0, 0, 201, 202, 5, 4, 0, 0, 202, 203, 5, 70, 0, 0, 203, 204, 5, 4, 0, 0, 204, 205, 3, 0, 0, 0, 205, 206, 5, 2, 0, 0, 206, 236, 1, 0, 0, 0, 207, 208, 5, 64, 0, 0, 208, 209, 5, 1, 0, 0, 209, 210, 5, 68, 0, 0, 210, 236, 5, 2, 0, 0, 211, 212, 5, 54, 0, 0, 212, 213, 5, 1, 0, 0, 213, 214, 7, 7, 0, 0, 214, 236, 5, 2, 0, 0, 215, 216, 5, 68, 0, 0, 216, 228, 5, 1, 0, 0, 217, 222, 3, 0, 0, 0, 218, 219, 5, 4, 0, 0, 219, 221, 3, 0, 0, 0, 220, 218, 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 220, 1, 0, 0, 0, 222, 223, 1, 0, 0, 0, 223, 226, 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 225, 227, 5, 4, 0, 0, 226, 225, 1, 0, 0, 0, 226, 227, 1, 0, 0, 0, 227, 229, 1, 0, 0, 0, 228, 217, 1, 0, 0, 0, 228, 229, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 236, 5, 2, 0, 0, 231, 232, 7, 7, 0, 0, 232, 236, 5, 42, 0, 0, 233, 234, 7, 7, 0, 0, 234, 236, 5, 43, 0, 0, 235, 4, 1, 0, 0, 0, 235, 14, 1, 0, 0, 0, 235, 23, 1, 0, 0, 0, 235, 24, 1, 0, 0, 0, 235, 25, 1, 0, 0, 0, 235, 26, 1, 0, 0, 0, 235, 27, 1, 0, 0, 0, 235, 28, 1, 0, 0, 0, 235, 29, 1, 0, 0, 0, 235, 30, 1, 0, 0, 0, 235, 33, 1, 0, 0, 0, 235, 37, 1, 0, 0, 0, 235, 51, 1, 0, 0, 0, 235, 52, 1, 0, 0, 0, 235, 54, 1, 0, 0, 0, 235, 64, 1, 0, 0, 0, 235, 74, 1, 0, 0, 0, 235, 79, 1, 0, 0, 0, 235, 86, 1, 0, 0, 0, 235, 93, 1, 0, 0, 0, 235, 100, 1, 0, 0, 0, 235, 111, 1, 0, 0, 0, 235, 122, 1, 0, 0, 0, 235, 133, 1, 0, 0, 0, 235, 135, 1, 0, 0, 0, 235, 142, 1, 0, 0, 0, 235, 149, 1, 0, 0, 0, 235, 156, 1, 0, 0, 0, 235, 162, 1, 0, 0, 0, 235, 168, 1, 0, 0, 0, 235, 174, 1, 0, 0, 0, 235, 180, 1, 0, 0, 0, 235, 186, 1, 0, 0, 0, 235, 192, 1, 0, 0, 0, 235, 198, 1, 0, 0, 0, 235, 207, 1, 0, 0, 0, 235, 211, 1, 0, 0, 0, 235, 215, 1, 0, 0, 0, 235, 231, 1, 0, 0, 0, 235, 233, 1, 0, 0, 0, 236, 291, 1, 0, 0, 0, 237, 238, 10, 31, 0, 0, 238, 239, 5, 34, 0, 0, 239, 290, 3, 0, 0, 32, 240, 241, 10, 29, 0, 0, 241, 242, 7, 8, 0, 0, 242, 290, 3, 0, 0, 30, 243, 244, 10, 28, 0, 0, 244, 245, 7, 0, 0, 0, 245, 290, 3, 0, 0, 29, 246, 247, 10, 27, 0, 0, 247, 248, 7, 9, 0, 0, 248, 290, 3, 0, 0, 28, 249, 251, 10, 26, 0, 0, 250, 252, 5, 45, 0, 0, 251, 250, 1, 0, 0, 0, 251, 252, 1, 0, 0, 0, 252, 253, 1, 0, 0, 0, 253, 254, 5, 46, 0, 0, 254, 290, 3, 0, 0, 27, 255, 256, 10, 11, 0, 0, 256, 257, 7, 10, 0, 0, 257, 258, 7, 11, 0, 0, 258, 259, 7, 10, 0, 0, 259, 290, 3, 0, 0, 12, 260, 261, 10, 10, 0, 0, 261, 262, 7, 12, 0, 0, 262, 263, 7, 11, 0, 0, 263, 264, 7, 12, 0, 0, 264, 290, 3, 0, 0, 11, 265, 266, 10, 9, 0, 0, 266, 267, 7, 13, 0, 0, 267, 290, 3, 0, 0, 10, 268, 269, 10, 8, 0, 0, 269, 270, 7, 14, 0, 0, 270, 290, 3, 0, 0, 9, 271, 272, 10, 7, 0, 0, 272, 273, 5, 37, 0, 0, 273, 290, 3, 0, 0, 8, 274, 275, 10, 6, 0, 0, 275, 276, 5, 39, 0, 0, 276, 290, 3, 0, 0, 7, 277, 278, 10, 5, 0, 0, 278, 279, 5, 38, 0, 0, 279, 290, 3, 0, 0, 6, 280, 281, 10, 4, 0, 0, 281, 282, 5, 40, 0, 0, 282, 290, 3, 0, 0, 5, 283, 284, 10, 3, 0, 0, 284, 285, 5, 41, 0, 0, 285, 290, 3, 0, 0, 4, 286, 287, 10, 41, 0, 0, 287, 288, 5, 14, 0, 0, 288, 290, 5, 70, 0, 0, 289, 237, 1, 0, 0, 0, 289, 240, 1, 0, 0, 0, 289, 243, 1, 0, 0, 0, 289, 246, 1, 0, 0, 0, 289, 249, 1, 0, 0, 0, 289, 255, 1, 0, 0, 0, 289, 260, 1, 0, 0, 0, 289, 265, 1, 0, 0, 0, 289, 268, 1, 0, 0, 0, 289, 271, 1, 0, 0, 0, 289, 274, 1, 0, 0, 0, 289, 277, 1, 0, 0, 0, 289, 280, 1, 0, 0, 0, 289, 283, 1, 0, 0, 0, 289, 286, 1, 0, 0, 0, 290, 293, 1, 0, 0, 0, 291, 289, 1, 0, 0, 0, 291, 292, 1, 0, 0, 0, 292, 1, 1, 0, 0, 0, 293, 291, 1, 0, 0, 0, 294, 295, 5, 26, 0, 0, 295, 296, 5, 28, 0, 0, 296, 297, 5, 66, 0, 0, 297, 3, 1, 0, 0, 0, 13, 9, 21, 43, 47, 61, 71, 222, 226, 228, 235, 251, 289, 291] \ No newline at end of file diff --git a/internal/parser/planparserv2/generated/Plan.tokens b/internal/parser/planparserv2/generated/Plan.tokens index 374477f781..4e6be20d92 100644 --- a/internal/parser/planparserv2/generated/Plan.tokens +++ b/internal/parser/planparserv2/generated/Plan.tokens @@ -16,56 +16,62 @@ EXISTS=15 TEXTMATCH=16 PHRASEMATCH=17 RANDOMSAMPLE=18 -INTERVAL=19 -ISO=20 -MINIMUM_SHOULD_MATCH=21 -ASSIGN=22 -ADD=23 -SUB=24 -MUL=25 -DIV=26 -MOD=27 -POW=28 -SHL=29 -SHR=30 -BAND=31 -BOR=32 -BXOR=33 -AND=34 -OR=35 -ISNULL=36 -ISNOTNULL=37 -BNOT=38 -NOT=39 -IN=40 -EmptyArray=41 -JSONContains=42 -JSONContainsAll=43 -JSONContainsAny=44 -ArrayContains=45 -ArrayContainsAll=46 -ArrayContainsAny=47 -ArrayLength=48 -ElementFilter=49 -STEuqals=50 -STTouches=51 -STOverlaps=52 -STCrosses=53 -STContains=54 -STIntersects=55 -STWithin=56 -STDWithin=57 -STIsValid=58 -BooleanConstant=59 -IntegerConstant=60 -FloatingConstant=61 -Identifier=62 -Meta=63 -StringLiteral=64 -JSONIdentifier=65 -StructSubFieldIdentifier=66 -Whitespace=67 -Newline=68 +MATCH_ALL=19 +MATCH_ANY=20 +MATCH_LEAST=21 +MATCH_MOST=22 +MATCH_EXACT=23 +INTERVAL=24 +ISO=25 +MINIMUM_SHOULD_MATCH=26 +THRESHOLD=27 +ASSIGN=28 +ADD=29 +SUB=30 +MUL=31 +DIV=32 +MOD=33 +POW=34 +SHL=35 +SHR=36 +BAND=37 +BOR=38 +BXOR=39 +AND=40 +OR=41 +ISNULL=42 +ISNOTNULL=43 +BNOT=44 +NOT=45 +IN=46 +EmptyArray=47 +JSONContains=48 +JSONContainsAll=49 +JSONContainsAny=50 +ArrayContains=51 +ArrayContainsAll=52 +ArrayContainsAny=53 +ArrayLength=54 +ElementFilter=55 +STEuqals=56 +STTouches=57 +STOverlaps=58 +STCrosses=59 +STContains=60 +STIntersects=61 +STWithin=62 +STDWithin=63 +STIsValid=64 +BooleanConstant=65 +IntegerConstant=66 +FloatingConstant=67 +Identifier=68 +Meta=69 +StringLiteral=70 +JSONIdentifier=71 +StructSubFieldIdentifier=72 +Whitespace=73 +Newline=74 '('=1 ')'=2 '['=3 @@ -79,17 +85,17 @@ Newline=68 '>='=11 '=='=12 '!='=13 -'='=22 -'+'=23 -'-'=24 -'*'=25 -'/'=26 -'%'=27 -'**'=28 -'<<'=29 -'>>'=30 -'&'=31 -'|'=32 -'^'=33 -'~'=38 -'$meta'=63 +'='=28 +'+'=29 +'-'=30 +'*'=31 +'/'=32 +'%'=33 +'**'=34 +'<<'=35 +'>>'=36 +'&'=37 +'|'=38 +'^'=39 +'~'=44 +'$meta'=69 diff --git a/internal/parser/planparserv2/generated/PlanLexer.interp b/internal/parser/planparserv2/generated/PlanLexer.interp index 343557898e..76e41671a4 100644 --- a/internal/parser/planparserv2/generated/PlanLexer.interp +++ b/internal/parser/planparserv2/generated/PlanLexer.interp @@ -21,6 +21,12 @@ null null null null +null +null +null +null +null +null '=' '+' '-' @@ -89,9 +95,15 @@ EXISTS TEXTMATCH PHRASEMATCH RANDOMSAMPLE +MATCH_ALL +MATCH_ANY +MATCH_LEAST +MATCH_MOST +MATCH_EXACT INTERVAL ISO MINIMUM_SHOULD_MATCH +THRESHOLD ASSIGN ADD SUB @@ -159,9 +171,15 @@ EXISTS TEXTMATCH PHRASEMATCH RANDOMSAMPLE +MATCH_ALL +MATCH_ANY +MATCH_LEAST +MATCH_MOST +MATCH_EXACT INTERVAL ISO MINIMUM_SHOULD_MATCH +THRESHOLD ASSIGN ADD SUB @@ -243,4 +261,4 @@ mode names: DEFAULT_MODE atn: -[4, 0, 68, 1232, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 226, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 240, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 262, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 288, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 316, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 334, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 342, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 384, 8, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 421, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 429, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 445, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 469, 8, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 480, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 486, 8, 39, 1, 40, 1, 40, 1, 40, 5, 40, 491, 8, 40, 10, 40, 12, 40, 494, 9, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 524, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 560, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 596, 8, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 626, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 664, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 702, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 728, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 758, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 778, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 800, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 824, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 846, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 870, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 898, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 918, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 940, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 962, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 991, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 997, 8, 59, 1, 60, 1, 60, 3, 60, 1001, 8, 60, 1, 61, 1, 61, 1, 61, 5, 61, 1006, 8, 61, 10, 61, 12, 61, 1009, 9, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 3, 63, 1018, 8, 63, 1, 63, 1, 63, 3, 63, 1022, 8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1027, 8, 63, 1, 63, 3, 63, 1030, 8, 63, 1, 64, 1, 64, 3, 64, 1034, 8, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1039, 8, 64, 1, 64, 1, 64, 4, 64, 1043, 8, 64, 11, 64, 12, 64, 1044, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 3, 66, 1056, 8, 66, 1, 67, 4, 67, 1059, 8, 67, 11, 67, 12, 67, 1060, 1, 68, 4, 68, 1064, 8, 68, 11, 68, 12, 68, 1065, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1075, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1084, 8, 70, 1, 71, 1, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 4, 73, 1093, 8, 73, 11, 73, 12, 73, 1094, 1, 74, 1, 74, 5, 74, 1099, 8, 74, 10, 74, 12, 74, 1102, 9, 74, 1, 74, 3, 74, 1105, 8, 74, 1, 75, 1, 75, 5, 75, 1109, 8, 75, 10, 75, 12, 75, 1112, 9, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1139, 8, 81, 1, 82, 1, 82, 3, 82, 1143, 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1148, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1154, 8, 83, 1, 83, 1, 83, 1, 84, 3, 84, 1159, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1166, 8, 84, 1, 85, 1, 85, 3, 85, 1170, 8, 85, 1, 85, 1, 85, 1, 86, 4, 86, 1175, 8, 86, 11, 86, 12, 86, 1176, 1, 87, 3, 87, 1180, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1187, 8, 87, 1, 88, 4, 88, 1190, 8, 88, 11, 88, 12, 88, 1191, 1, 89, 1, 89, 3, 89, 1196, 8, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1205, 8, 90, 1, 90, 3, 90, 1208, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1215, 8, 90, 1, 91, 4, 91, 1218, 8, 91, 11, 91, 12, 91, 1219, 1, 91, 1, 91, 1, 92, 1, 92, 3, 92, 1226, 8, 92, 1, 92, 3, 92, 1229, 8, 92, 1, 92, 1, 92, 0, 0, 93, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 0, 135, 0, 137, 0, 139, 0, 141, 0, 143, 0, 145, 0, 147, 0, 149, 0, 151, 0, 153, 0, 155, 0, 157, 0, 159, 0, 161, 0, 163, 0, 165, 0, 167, 0, 169, 0, 171, 0, 173, 0, 175, 0, 177, 0, 179, 0, 181, 0, 183, 67, 185, 68, 1, 0, 16, 3, 0, 76, 76, 85, 85, 117, 117, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 3, 0, 65, 90, 95, 95, 97, 122, 1, 0, 48, 57, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 2, 0, 88, 88, 120, 120, 1, 0, 49, 57, 1, 0, 48, 55, 3, 0, 48, 57, 65, 70, 97, 102, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 80, 80, 112, 112, 10, 0, 34, 34, 39, 39, 63, 63, 92, 92, 97, 98, 102, 102, 110, 110, 114, 114, 116, 116, 118, 118, 2, 0, 9, 9, 32, 32, 1293, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 1, 187, 1, 0, 0, 0, 3, 189, 1, 0, 0, 0, 5, 191, 1, 0, 0, 0, 7, 193, 1, 0, 0, 0, 9, 195, 1, 0, 0, 0, 11, 197, 1, 0, 0, 0, 13, 199, 1, 0, 0, 0, 15, 201, 1, 0, 0, 0, 17, 203, 1, 0, 0, 0, 19, 206, 1, 0, 0, 0, 21, 208, 1, 0, 0, 0, 23, 211, 1, 0, 0, 0, 25, 214, 1, 0, 0, 0, 27, 225, 1, 0, 0, 0, 29, 239, 1, 0, 0, 0, 31, 261, 1, 0, 0, 0, 33, 287, 1, 0, 0, 0, 35, 315, 1, 0, 0, 0, 37, 333, 1, 0, 0, 0, 39, 341, 1, 0, 0, 0, 41, 383, 1, 0, 0, 0, 43, 385, 1, 0, 0, 0, 45, 387, 1, 0, 0, 0, 47, 389, 1, 0, 0, 0, 49, 391, 1, 0, 0, 0, 51, 393, 1, 0, 0, 0, 53, 395, 1, 0, 0, 0, 55, 397, 1, 0, 0, 0, 57, 400, 1, 0, 0, 0, 59, 403, 1, 0, 0, 0, 61, 406, 1, 0, 0, 0, 63, 408, 1, 0, 0, 0, 65, 410, 1, 0, 0, 0, 67, 420, 1, 0, 0, 0, 69, 428, 1, 0, 0, 0, 71, 444, 1, 0, 0, 0, 73, 468, 1, 0, 0, 0, 75, 470, 1, 0, 0, 0, 77, 479, 1, 0, 0, 0, 79, 485, 1, 0, 0, 0, 81, 487, 1, 0, 0, 0, 83, 523, 1, 0, 0, 0, 85, 559, 1, 0, 0, 0, 87, 595, 1, 0, 0, 0, 89, 625, 1, 0, 0, 0, 91, 663, 1, 0, 0, 0, 93, 701, 1, 0, 0, 0, 95, 727, 1, 0, 0, 0, 97, 757, 1, 0, 0, 0, 99, 777, 1, 0, 0, 0, 101, 799, 1, 0, 0, 0, 103, 823, 1, 0, 0, 0, 105, 845, 1, 0, 0, 0, 107, 869, 1, 0, 0, 0, 109, 897, 1, 0, 0, 0, 111, 917, 1, 0, 0, 0, 113, 939, 1, 0, 0, 0, 115, 961, 1, 0, 0, 0, 117, 990, 1, 0, 0, 0, 119, 996, 1, 0, 0, 0, 121, 1000, 1, 0, 0, 0, 123, 1002, 1, 0, 0, 0, 125, 1010, 1, 0, 0, 0, 127, 1017, 1, 0, 0, 0, 129, 1033, 1, 0, 0, 0, 131, 1046, 1, 0, 0, 0, 133, 1055, 1, 0, 0, 0, 135, 1058, 1, 0, 0, 0, 137, 1063, 1, 0, 0, 0, 139, 1074, 1, 0, 0, 0, 141, 1083, 1, 0, 0, 0, 143, 1085, 1, 0, 0, 0, 145, 1087, 1, 0, 0, 0, 147, 1089, 1, 0, 0, 0, 149, 1104, 1, 0, 0, 0, 151, 1106, 1, 0, 0, 0, 153, 1113, 1, 0, 0, 0, 155, 1117, 1, 0, 0, 0, 157, 1119, 1, 0, 0, 0, 159, 1121, 1, 0, 0, 0, 161, 1123, 1, 0, 0, 0, 163, 1138, 1, 0, 0, 0, 165, 1147, 1, 0, 0, 0, 167, 1149, 1, 0, 0, 0, 169, 1165, 1, 0, 0, 0, 171, 1167, 1, 0, 0, 0, 173, 1174, 1, 0, 0, 0, 175, 1186, 1, 0, 0, 0, 177, 1189, 1, 0, 0, 0, 179, 1193, 1, 0, 0, 0, 181, 1214, 1, 0, 0, 0, 183, 1217, 1, 0, 0, 0, 185, 1228, 1, 0, 0, 0, 187, 188, 5, 40, 0, 0, 188, 2, 1, 0, 0, 0, 189, 190, 5, 41, 0, 0, 190, 4, 1, 0, 0, 0, 191, 192, 5, 91, 0, 0, 192, 6, 1, 0, 0, 0, 193, 194, 5, 44, 0, 0, 194, 8, 1, 0, 0, 0, 195, 196, 5, 93, 0, 0, 196, 10, 1, 0, 0, 0, 197, 198, 5, 123, 0, 0, 198, 12, 1, 0, 0, 0, 199, 200, 5, 125, 0, 0, 200, 14, 1, 0, 0, 0, 201, 202, 5, 60, 0, 0, 202, 16, 1, 0, 0, 0, 203, 204, 5, 60, 0, 0, 204, 205, 5, 61, 0, 0, 205, 18, 1, 0, 0, 0, 206, 207, 5, 62, 0, 0, 207, 20, 1, 0, 0, 0, 208, 209, 5, 62, 0, 0, 209, 210, 5, 61, 0, 0, 210, 22, 1, 0, 0, 0, 211, 212, 5, 61, 0, 0, 212, 213, 5, 61, 0, 0, 213, 24, 1, 0, 0, 0, 214, 215, 5, 33, 0, 0, 215, 216, 5, 61, 0, 0, 216, 26, 1, 0, 0, 0, 217, 218, 5, 108, 0, 0, 218, 219, 5, 105, 0, 0, 219, 220, 5, 107, 0, 0, 220, 226, 5, 101, 0, 0, 221, 222, 5, 76, 0, 0, 222, 223, 5, 73, 0, 0, 223, 224, 5, 75, 0, 0, 224, 226, 5, 69, 0, 0, 225, 217, 1, 0, 0, 0, 225, 221, 1, 0, 0, 0, 226, 28, 1, 0, 0, 0, 227, 228, 5, 101, 0, 0, 228, 229, 5, 120, 0, 0, 229, 230, 5, 105, 0, 0, 230, 231, 5, 115, 0, 0, 231, 232, 5, 116, 0, 0, 232, 240, 5, 115, 0, 0, 233, 234, 5, 69, 0, 0, 234, 235, 5, 88, 0, 0, 235, 236, 5, 73, 0, 0, 236, 237, 5, 83, 0, 0, 237, 238, 5, 84, 0, 0, 238, 240, 5, 83, 0, 0, 239, 227, 1, 0, 0, 0, 239, 233, 1, 0, 0, 0, 240, 30, 1, 0, 0, 0, 241, 242, 5, 116, 0, 0, 242, 243, 5, 101, 0, 0, 243, 244, 5, 120, 0, 0, 244, 245, 5, 116, 0, 0, 245, 246, 5, 95, 0, 0, 246, 247, 5, 109, 0, 0, 247, 248, 5, 97, 0, 0, 248, 249, 5, 116, 0, 0, 249, 250, 5, 99, 0, 0, 250, 262, 5, 104, 0, 0, 251, 252, 5, 84, 0, 0, 252, 253, 5, 69, 0, 0, 253, 254, 5, 88, 0, 0, 254, 255, 5, 84, 0, 0, 255, 256, 5, 95, 0, 0, 256, 257, 5, 77, 0, 0, 257, 258, 5, 65, 0, 0, 258, 259, 5, 84, 0, 0, 259, 260, 5, 67, 0, 0, 260, 262, 5, 72, 0, 0, 261, 241, 1, 0, 0, 0, 261, 251, 1, 0, 0, 0, 262, 32, 1, 0, 0, 0, 263, 264, 5, 112, 0, 0, 264, 265, 5, 104, 0, 0, 265, 266, 5, 114, 0, 0, 266, 267, 5, 97, 0, 0, 267, 268, 5, 115, 0, 0, 268, 269, 5, 101, 0, 0, 269, 270, 5, 95, 0, 0, 270, 271, 5, 109, 0, 0, 271, 272, 5, 97, 0, 0, 272, 273, 5, 116, 0, 0, 273, 274, 5, 99, 0, 0, 274, 288, 5, 104, 0, 0, 275, 276, 5, 80, 0, 0, 276, 277, 5, 72, 0, 0, 277, 278, 5, 82, 0, 0, 278, 279, 5, 65, 0, 0, 279, 280, 5, 83, 0, 0, 280, 281, 5, 69, 0, 0, 281, 282, 5, 95, 0, 0, 282, 283, 5, 77, 0, 0, 283, 284, 5, 65, 0, 0, 284, 285, 5, 84, 0, 0, 285, 286, 5, 67, 0, 0, 286, 288, 5, 72, 0, 0, 287, 263, 1, 0, 0, 0, 287, 275, 1, 0, 0, 0, 288, 34, 1, 0, 0, 0, 289, 290, 5, 114, 0, 0, 290, 291, 5, 97, 0, 0, 291, 292, 5, 110, 0, 0, 292, 293, 5, 100, 0, 0, 293, 294, 5, 111, 0, 0, 294, 295, 5, 109, 0, 0, 295, 296, 5, 95, 0, 0, 296, 297, 5, 115, 0, 0, 297, 298, 5, 97, 0, 0, 298, 299, 5, 109, 0, 0, 299, 300, 5, 112, 0, 0, 300, 301, 5, 108, 0, 0, 301, 316, 5, 101, 0, 0, 302, 303, 5, 82, 0, 0, 303, 304, 5, 65, 0, 0, 304, 305, 5, 78, 0, 0, 305, 306, 5, 68, 0, 0, 306, 307, 5, 79, 0, 0, 307, 308, 5, 77, 0, 0, 308, 309, 5, 95, 0, 0, 309, 310, 5, 83, 0, 0, 310, 311, 5, 65, 0, 0, 311, 312, 5, 77, 0, 0, 312, 313, 5, 80, 0, 0, 313, 314, 5, 76, 0, 0, 314, 316, 5, 69, 0, 0, 315, 289, 1, 0, 0, 0, 315, 302, 1, 0, 0, 0, 316, 36, 1, 0, 0, 0, 317, 318, 5, 105, 0, 0, 318, 319, 5, 110, 0, 0, 319, 320, 5, 116, 0, 0, 320, 321, 5, 101, 0, 0, 321, 322, 5, 114, 0, 0, 322, 323, 5, 118, 0, 0, 323, 324, 5, 97, 0, 0, 324, 334, 5, 108, 0, 0, 325, 326, 5, 73, 0, 0, 326, 327, 5, 78, 0, 0, 327, 328, 5, 84, 0, 0, 328, 329, 5, 69, 0, 0, 329, 330, 5, 82, 0, 0, 330, 331, 5, 86, 0, 0, 331, 332, 5, 65, 0, 0, 332, 334, 5, 76, 0, 0, 333, 317, 1, 0, 0, 0, 333, 325, 1, 0, 0, 0, 334, 38, 1, 0, 0, 0, 335, 336, 5, 105, 0, 0, 336, 337, 5, 115, 0, 0, 337, 342, 5, 111, 0, 0, 338, 339, 5, 73, 0, 0, 339, 340, 5, 83, 0, 0, 340, 342, 5, 79, 0, 0, 341, 335, 1, 0, 0, 0, 341, 338, 1, 0, 0, 0, 342, 40, 1, 0, 0, 0, 343, 344, 5, 109, 0, 0, 344, 345, 5, 105, 0, 0, 345, 346, 5, 110, 0, 0, 346, 347, 5, 105, 0, 0, 347, 348, 5, 109, 0, 0, 348, 349, 5, 117, 0, 0, 349, 350, 5, 109, 0, 0, 350, 351, 5, 95, 0, 0, 351, 352, 5, 115, 0, 0, 352, 353, 5, 104, 0, 0, 353, 354, 5, 111, 0, 0, 354, 355, 5, 117, 0, 0, 355, 356, 5, 108, 0, 0, 356, 357, 5, 100, 0, 0, 357, 358, 5, 95, 0, 0, 358, 359, 5, 109, 0, 0, 359, 360, 5, 97, 0, 0, 360, 361, 5, 116, 0, 0, 361, 362, 5, 99, 0, 0, 362, 384, 5, 104, 0, 0, 363, 364, 5, 77, 0, 0, 364, 365, 5, 73, 0, 0, 365, 366, 5, 78, 0, 0, 366, 367, 5, 73, 0, 0, 367, 368, 5, 77, 0, 0, 368, 369, 5, 85, 0, 0, 369, 370, 5, 77, 0, 0, 370, 371, 5, 95, 0, 0, 371, 372, 5, 83, 0, 0, 372, 373, 5, 72, 0, 0, 373, 374, 5, 79, 0, 0, 374, 375, 5, 85, 0, 0, 375, 376, 5, 76, 0, 0, 376, 377, 5, 68, 0, 0, 377, 378, 5, 95, 0, 0, 378, 379, 5, 77, 0, 0, 379, 380, 5, 65, 0, 0, 380, 381, 5, 84, 0, 0, 381, 382, 5, 67, 0, 0, 382, 384, 5, 72, 0, 0, 383, 343, 1, 0, 0, 0, 383, 363, 1, 0, 0, 0, 384, 42, 1, 0, 0, 0, 385, 386, 5, 61, 0, 0, 386, 44, 1, 0, 0, 0, 387, 388, 5, 43, 0, 0, 388, 46, 1, 0, 0, 0, 389, 390, 5, 45, 0, 0, 390, 48, 1, 0, 0, 0, 391, 392, 5, 42, 0, 0, 392, 50, 1, 0, 0, 0, 393, 394, 5, 47, 0, 0, 394, 52, 1, 0, 0, 0, 395, 396, 5, 37, 0, 0, 396, 54, 1, 0, 0, 0, 397, 398, 5, 42, 0, 0, 398, 399, 5, 42, 0, 0, 399, 56, 1, 0, 0, 0, 400, 401, 5, 60, 0, 0, 401, 402, 5, 60, 0, 0, 402, 58, 1, 0, 0, 0, 403, 404, 5, 62, 0, 0, 404, 405, 5, 62, 0, 0, 405, 60, 1, 0, 0, 0, 406, 407, 5, 38, 0, 0, 407, 62, 1, 0, 0, 0, 408, 409, 5, 124, 0, 0, 409, 64, 1, 0, 0, 0, 410, 411, 5, 94, 0, 0, 411, 66, 1, 0, 0, 0, 412, 413, 5, 38, 0, 0, 413, 421, 5, 38, 0, 0, 414, 415, 5, 97, 0, 0, 415, 416, 5, 110, 0, 0, 416, 421, 5, 100, 0, 0, 417, 418, 5, 65, 0, 0, 418, 419, 5, 78, 0, 0, 419, 421, 5, 68, 0, 0, 420, 412, 1, 0, 0, 0, 420, 414, 1, 0, 0, 0, 420, 417, 1, 0, 0, 0, 421, 68, 1, 0, 0, 0, 422, 423, 5, 124, 0, 0, 423, 429, 5, 124, 0, 0, 424, 425, 5, 111, 0, 0, 425, 429, 5, 114, 0, 0, 426, 427, 5, 79, 0, 0, 427, 429, 5, 82, 0, 0, 428, 422, 1, 0, 0, 0, 428, 424, 1, 0, 0, 0, 428, 426, 1, 0, 0, 0, 429, 70, 1, 0, 0, 0, 430, 431, 5, 105, 0, 0, 431, 432, 5, 115, 0, 0, 432, 433, 5, 32, 0, 0, 433, 434, 5, 110, 0, 0, 434, 435, 5, 117, 0, 0, 435, 436, 5, 108, 0, 0, 436, 445, 5, 108, 0, 0, 437, 438, 5, 73, 0, 0, 438, 439, 5, 83, 0, 0, 439, 440, 5, 32, 0, 0, 440, 441, 5, 78, 0, 0, 441, 442, 5, 85, 0, 0, 442, 443, 5, 76, 0, 0, 443, 445, 5, 76, 0, 0, 444, 430, 1, 0, 0, 0, 444, 437, 1, 0, 0, 0, 445, 72, 1, 0, 0, 0, 446, 447, 5, 105, 0, 0, 447, 448, 5, 115, 0, 0, 448, 449, 5, 32, 0, 0, 449, 450, 5, 110, 0, 0, 450, 451, 5, 111, 0, 0, 451, 452, 5, 116, 0, 0, 452, 453, 5, 32, 0, 0, 453, 454, 5, 110, 0, 0, 454, 455, 5, 117, 0, 0, 455, 456, 5, 108, 0, 0, 456, 469, 5, 108, 0, 0, 457, 458, 5, 73, 0, 0, 458, 459, 5, 83, 0, 0, 459, 460, 5, 32, 0, 0, 460, 461, 5, 78, 0, 0, 461, 462, 5, 79, 0, 0, 462, 463, 5, 84, 0, 0, 463, 464, 5, 32, 0, 0, 464, 465, 5, 78, 0, 0, 465, 466, 5, 85, 0, 0, 466, 467, 5, 76, 0, 0, 467, 469, 5, 76, 0, 0, 468, 446, 1, 0, 0, 0, 468, 457, 1, 0, 0, 0, 469, 74, 1, 0, 0, 0, 470, 471, 5, 126, 0, 0, 471, 76, 1, 0, 0, 0, 472, 480, 5, 33, 0, 0, 473, 474, 5, 110, 0, 0, 474, 475, 5, 111, 0, 0, 475, 480, 5, 116, 0, 0, 476, 477, 5, 78, 0, 0, 477, 478, 5, 79, 0, 0, 478, 480, 5, 84, 0, 0, 479, 472, 1, 0, 0, 0, 479, 473, 1, 0, 0, 0, 479, 476, 1, 0, 0, 0, 480, 78, 1, 0, 0, 0, 481, 482, 5, 105, 0, 0, 482, 486, 5, 110, 0, 0, 483, 484, 5, 73, 0, 0, 484, 486, 5, 78, 0, 0, 485, 481, 1, 0, 0, 0, 485, 483, 1, 0, 0, 0, 486, 80, 1, 0, 0, 0, 487, 492, 5, 91, 0, 0, 488, 491, 3, 183, 91, 0, 489, 491, 3, 185, 92, 0, 490, 488, 1, 0, 0, 0, 490, 489, 1, 0, 0, 0, 491, 494, 1, 0, 0, 0, 492, 490, 1, 0, 0, 0, 492, 493, 1, 0, 0, 0, 493, 495, 1, 0, 0, 0, 494, 492, 1, 0, 0, 0, 495, 496, 5, 93, 0, 0, 496, 82, 1, 0, 0, 0, 497, 498, 5, 106, 0, 0, 498, 499, 5, 115, 0, 0, 499, 500, 5, 111, 0, 0, 500, 501, 5, 110, 0, 0, 501, 502, 5, 95, 0, 0, 502, 503, 5, 99, 0, 0, 503, 504, 5, 111, 0, 0, 504, 505, 5, 110, 0, 0, 505, 506, 5, 116, 0, 0, 506, 507, 5, 97, 0, 0, 507, 508, 5, 105, 0, 0, 508, 509, 5, 110, 0, 0, 509, 524, 5, 115, 0, 0, 510, 511, 5, 74, 0, 0, 511, 512, 5, 83, 0, 0, 512, 513, 5, 79, 0, 0, 513, 514, 5, 78, 0, 0, 514, 515, 5, 95, 0, 0, 515, 516, 5, 67, 0, 0, 516, 517, 5, 79, 0, 0, 517, 518, 5, 78, 0, 0, 518, 519, 5, 84, 0, 0, 519, 520, 5, 65, 0, 0, 520, 521, 5, 73, 0, 0, 521, 522, 5, 78, 0, 0, 522, 524, 5, 83, 0, 0, 523, 497, 1, 0, 0, 0, 523, 510, 1, 0, 0, 0, 524, 84, 1, 0, 0, 0, 525, 526, 5, 106, 0, 0, 526, 527, 5, 115, 0, 0, 527, 528, 5, 111, 0, 0, 528, 529, 5, 110, 0, 0, 529, 530, 5, 95, 0, 0, 530, 531, 5, 99, 0, 0, 531, 532, 5, 111, 0, 0, 532, 533, 5, 110, 0, 0, 533, 534, 5, 116, 0, 0, 534, 535, 5, 97, 0, 0, 535, 536, 5, 105, 0, 0, 536, 537, 5, 110, 0, 0, 537, 538, 5, 115, 0, 0, 538, 539, 5, 95, 0, 0, 539, 540, 5, 97, 0, 0, 540, 541, 5, 108, 0, 0, 541, 560, 5, 108, 0, 0, 542, 543, 5, 74, 0, 0, 543, 544, 5, 83, 0, 0, 544, 545, 5, 79, 0, 0, 545, 546, 5, 78, 0, 0, 546, 547, 5, 95, 0, 0, 547, 548, 5, 67, 0, 0, 548, 549, 5, 79, 0, 0, 549, 550, 5, 78, 0, 0, 550, 551, 5, 84, 0, 0, 551, 552, 5, 65, 0, 0, 552, 553, 5, 73, 0, 0, 553, 554, 5, 78, 0, 0, 554, 555, 5, 83, 0, 0, 555, 556, 5, 95, 0, 0, 556, 557, 5, 65, 0, 0, 557, 558, 5, 76, 0, 0, 558, 560, 5, 76, 0, 0, 559, 525, 1, 0, 0, 0, 559, 542, 1, 0, 0, 0, 560, 86, 1, 0, 0, 0, 561, 562, 5, 106, 0, 0, 562, 563, 5, 115, 0, 0, 563, 564, 5, 111, 0, 0, 564, 565, 5, 110, 0, 0, 565, 566, 5, 95, 0, 0, 566, 567, 5, 99, 0, 0, 567, 568, 5, 111, 0, 0, 568, 569, 5, 110, 0, 0, 569, 570, 5, 116, 0, 0, 570, 571, 5, 97, 0, 0, 571, 572, 5, 105, 0, 0, 572, 573, 5, 110, 0, 0, 573, 574, 5, 115, 0, 0, 574, 575, 5, 95, 0, 0, 575, 576, 5, 97, 0, 0, 576, 577, 5, 110, 0, 0, 577, 596, 5, 121, 0, 0, 578, 579, 5, 74, 0, 0, 579, 580, 5, 83, 0, 0, 580, 581, 5, 79, 0, 0, 581, 582, 5, 78, 0, 0, 582, 583, 5, 95, 0, 0, 583, 584, 5, 67, 0, 0, 584, 585, 5, 79, 0, 0, 585, 586, 5, 78, 0, 0, 586, 587, 5, 84, 0, 0, 587, 588, 5, 65, 0, 0, 588, 589, 5, 73, 0, 0, 589, 590, 5, 78, 0, 0, 590, 591, 5, 83, 0, 0, 591, 592, 5, 95, 0, 0, 592, 593, 5, 65, 0, 0, 593, 594, 5, 78, 0, 0, 594, 596, 5, 89, 0, 0, 595, 561, 1, 0, 0, 0, 595, 578, 1, 0, 0, 0, 596, 88, 1, 0, 0, 0, 597, 598, 5, 97, 0, 0, 598, 599, 5, 114, 0, 0, 599, 600, 5, 114, 0, 0, 600, 601, 5, 97, 0, 0, 601, 602, 5, 121, 0, 0, 602, 603, 5, 95, 0, 0, 603, 604, 5, 99, 0, 0, 604, 605, 5, 111, 0, 0, 605, 606, 5, 110, 0, 0, 606, 607, 5, 116, 0, 0, 607, 608, 5, 97, 0, 0, 608, 609, 5, 105, 0, 0, 609, 610, 5, 110, 0, 0, 610, 626, 5, 115, 0, 0, 611, 612, 5, 65, 0, 0, 612, 613, 5, 82, 0, 0, 613, 614, 5, 82, 0, 0, 614, 615, 5, 65, 0, 0, 615, 616, 5, 89, 0, 0, 616, 617, 5, 95, 0, 0, 617, 618, 5, 67, 0, 0, 618, 619, 5, 79, 0, 0, 619, 620, 5, 78, 0, 0, 620, 621, 5, 84, 0, 0, 621, 622, 5, 65, 0, 0, 622, 623, 5, 73, 0, 0, 623, 624, 5, 78, 0, 0, 624, 626, 5, 83, 0, 0, 625, 597, 1, 0, 0, 0, 625, 611, 1, 0, 0, 0, 626, 90, 1, 0, 0, 0, 627, 628, 5, 97, 0, 0, 628, 629, 5, 114, 0, 0, 629, 630, 5, 114, 0, 0, 630, 631, 5, 97, 0, 0, 631, 632, 5, 121, 0, 0, 632, 633, 5, 95, 0, 0, 633, 634, 5, 99, 0, 0, 634, 635, 5, 111, 0, 0, 635, 636, 5, 110, 0, 0, 636, 637, 5, 116, 0, 0, 637, 638, 5, 97, 0, 0, 638, 639, 5, 105, 0, 0, 639, 640, 5, 110, 0, 0, 640, 641, 5, 115, 0, 0, 641, 642, 5, 95, 0, 0, 642, 643, 5, 97, 0, 0, 643, 644, 5, 108, 0, 0, 644, 664, 5, 108, 0, 0, 645, 646, 5, 65, 0, 0, 646, 647, 5, 82, 0, 0, 647, 648, 5, 82, 0, 0, 648, 649, 5, 65, 0, 0, 649, 650, 5, 89, 0, 0, 650, 651, 5, 95, 0, 0, 651, 652, 5, 67, 0, 0, 652, 653, 5, 79, 0, 0, 653, 654, 5, 78, 0, 0, 654, 655, 5, 84, 0, 0, 655, 656, 5, 65, 0, 0, 656, 657, 5, 73, 0, 0, 657, 658, 5, 78, 0, 0, 658, 659, 5, 83, 0, 0, 659, 660, 5, 95, 0, 0, 660, 661, 5, 65, 0, 0, 661, 662, 5, 76, 0, 0, 662, 664, 5, 76, 0, 0, 663, 627, 1, 0, 0, 0, 663, 645, 1, 0, 0, 0, 664, 92, 1, 0, 0, 0, 665, 666, 5, 97, 0, 0, 666, 667, 5, 114, 0, 0, 667, 668, 5, 114, 0, 0, 668, 669, 5, 97, 0, 0, 669, 670, 5, 121, 0, 0, 670, 671, 5, 95, 0, 0, 671, 672, 5, 99, 0, 0, 672, 673, 5, 111, 0, 0, 673, 674, 5, 110, 0, 0, 674, 675, 5, 116, 0, 0, 675, 676, 5, 97, 0, 0, 676, 677, 5, 105, 0, 0, 677, 678, 5, 110, 0, 0, 678, 679, 5, 115, 0, 0, 679, 680, 5, 95, 0, 0, 680, 681, 5, 97, 0, 0, 681, 682, 5, 110, 0, 0, 682, 702, 5, 121, 0, 0, 683, 684, 5, 65, 0, 0, 684, 685, 5, 82, 0, 0, 685, 686, 5, 82, 0, 0, 686, 687, 5, 65, 0, 0, 687, 688, 5, 89, 0, 0, 688, 689, 5, 95, 0, 0, 689, 690, 5, 67, 0, 0, 690, 691, 5, 79, 0, 0, 691, 692, 5, 78, 0, 0, 692, 693, 5, 84, 0, 0, 693, 694, 5, 65, 0, 0, 694, 695, 5, 73, 0, 0, 695, 696, 5, 78, 0, 0, 696, 697, 5, 83, 0, 0, 697, 698, 5, 95, 0, 0, 698, 699, 5, 65, 0, 0, 699, 700, 5, 78, 0, 0, 700, 702, 5, 89, 0, 0, 701, 665, 1, 0, 0, 0, 701, 683, 1, 0, 0, 0, 702, 94, 1, 0, 0, 0, 703, 704, 5, 97, 0, 0, 704, 705, 5, 114, 0, 0, 705, 706, 5, 114, 0, 0, 706, 707, 5, 97, 0, 0, 707, 708, 5, 121, 0, 0, 708, 709, 5, 95, 0, 0, 709, 710, 5, 108, 0, 0, 710, 711, 5, 101, 0, 0, 711, 712, 5, 110, 0, 0, 712, 713, 5, 103, 0, 0, 713, 714, 5, 116, 0, 0, 714, 728, 5, 104, 0, 0, 715, 716, 5, 65, 0, 0, 716, 717, 5, 82, 0, 0, 717, 718, 5, 82, 0, 0, 718, 719, 5, 65, 0, 0, 719, 720, 5, 89, 0, 0, 720, 721, 5, 95, 0, 0, 721, 722, 5, 76, 0, 0, 722, 723, 5, 69, 0, 0, 723, 724, 5, 78, 0, 0, 724, 725, 5, 71, 0, 0, 725, 726, 5, 84, 0, 0, 726, 728, 5, 72, 0, 0, 727, 703, 1, 0, 0, 0, 727, 715, 1, 0, 0, 0, 728, 96, 1, 0, 0, 0, 729, 730, 5, 101, 0, 0, 730, 731, 5, 108, 0, 0, 731, 732, 5, 101, 0, 0, 732, 733, 5, 109, 0, 0, 733, 734, 5, 101, 0, 0, 734, 735, 5, 110, 0, 0, 735, 736, 5, 116, 0, 0, 736, 737, 5, 95, 0, 0, 737, 738, 5, 102, 0, 0, 738, 739, 5, 105, 0, 0, 739, 740, 5, 108, 0, 0, 740, 741, 5, 116, 0, 0, 741, 742, 5, 101, 0, 0, 742, 758, 5, 114, 0, 0, 743, 744, 5, 69, 0, 0, 744, 745, 5, 76, 0, 0, 745, 746, 5, 69, 0, 0, 746, 747, 5, 77, 0, 0, 747, 748, 5, 69, 0, 0, 748, 749, 5, 78, 0, 0, 749, 750, 5, 84, 0, 0, 750, 751, 5, 95, 0, 0, 751, 752, 5, 70, 0, 0, 752, 753, 5, 73, 0, 0, 753, 754, 5, 76, 0, 0, 754, 755, 5, 84, 0, 0, 755, 756, 5, 69, 0, 0, 756, 758, 5, 82, 0, 0, 757, 729, 1, 0, 0, 0, 757, 743, 1, 0, 0, 0, 758, 98, 1, 0, 0, 0, 759, 760, 5, 115, 0, 0, 760, 761, 5, 116, 0, 0, 761, 762, 5, 95, 0, 0, 762, 763, 5, 101, 0, 0, 763, 764, 5, 113, 0, 0, 764, 765, 5, 117, 0, 0, 765, 766, 5, 97, 0, 0, 766, 767, 5, 108, 0, 0, 767, 778, 5, 115, 0, 0, 768, 769, 5, 83, 0, 0, 769, 770, 5, 84, 0, 0, 770, 771, 5, 95, 0, 0, 771, 772, 5, 69, 0, 0, 772, 773, 5, 81, 0, 0, 773, 774, 5, 85, 0, 0, 774, 775, 5, 65, 0, 0, 775, 776, 5, 76, 0, 0, 776, 778, 5, 83, 0, 0, 777, 759, 1, 0, 0, 0, 777, 768, 1, 0, 0, 0, 778, 100, 1, 0, 0, 0, 779, 780, 5, 115, 0, 0, 780, 781, 5, 116, 0, 0, 781, 782, 5, 95, 0, 0, 782, 783, 5, 116, 0, 0, 783, 784, 5, 111, 0, 0, 784, 785, 5, 117, 0, 0, 785, 786, 5, 99, 0, 0, 786, 787, 5, 104, 0, 0, 787, 788, 5, 101, 0, 0, 788, 800, 5, 115, 0, 0, 789, 790, 5, 83, 0, 0, 790, 791, 5, 84, 0, 0, 791, 792, 5, 95, 0, 0, 792, 793, 5, 84, 0, 0, 793, 794, 5, 79, 0, 0, 794, 795, 5, 85, 0, 0, 795, 796, 5, 67, 0, 0, 796, 797, 5, 72, 0, 0, 797, 798, 5, 69, 0, 0, 798, 800, 5, 83, 0, 0, 799, 779, 1, 0, 0, 0, 799, 789, 1, 0, 0, 0, 800, 102, 1, 0, 0, 0, 801, 802, 5, 115, 0, 0, 802, 803, 5, 116, 0, 0, 803, 804, 5, 95, 0, 0, 804, 805, 5, 111, 0, 0, 805, 806, 5, 118, 0, 0, 806, 807, 5, 101, 0, 0, 807, 808, 5, 114, 0, 0, 808, 809, 5, 108, 0, 0, 809, 810, 5, 97, 0, 0, 810, 811, 5, 112, 0, 0, 811, 824, 5, 115, 0, 0, 812, 813, 5, 83, 0, 0, 813, 814, 5, 84, 0, 0, 814, 815, 5, 95, 0, 0, 815, 816, 5, 79, 0, 0, 816, 817, 5, 86, 0, 0, 817, 818, 5, 69, 0, 0, 818, 819, 5, 82, 0, 0, 819, 820, 5, 76, 0, 0, 820, 821, 5, 65, 0, 0, 821, 822, 5, 80, 0, 0, 822, 824, 5, 83, 0, 0, 823, 801, 1, 0, 0, 0, 823, 812, 1, 0, 0, 0, 824, 104, 1, 0, 0, 0, 825, 826, 5, 115, 0, 0, 826, 827, 5, 116, 0, 0, 827, 828, 5, 95, 0, 0, 828, 829, 5, 99, 0, 0, 829, 830, 5, 114, 0, 0, 830, 831, 5, 111, 0, 0, 831, 832, 5, 115, 0, 0, 832, 833, 5, 115, 0, 0, 833, 834, 5, 101, 0, 0, 834, 846, 5, 115, 0, 0, 835, 836, 5, 83, 0, 0, 836, 837, 5, 84, 0, 0, 837, 838, 5, 95, 0, 0, 838, 839, 5, 67, 0, 0, 839, 840, 5, 82, 0, 0, 840, 841, 5, 79, 0, 0, 841, 842, 5, 83, 0, 0, 842, 843, 5, 83, 0, 0, 843, 844, 5, 69, 0, 0, 844, 846, 5, 83, 0, 0, 845, 825, 1, 0, 0, 0, 845, 835, 1, 0, 0, 0, 846, 106, 1, 0, 0, 0, 847, 848, 5, 115, 0, 0, 848, 849, 5, 116, 0, 0, 849, 850, 5, 95, 0, 0, 850, 851, 5, 99, 0, 0, 851, 852, 5, 111, 0, 0, 852, 853, 5, 110, 0, 0, 853, 854, 5, 116, 0, 0, 854, 855, 5, 97, 0, 0, 855, 856, 5, 105, 0, 0, 856, 857, 5, 110, 0, 0, 857, 870, 5, 115, 0, 0, 858, 859, 5, 83, 0, 0, 859, 860, 5, 84, 0, 0, 860, 861, 5, 95, 0, 0, 861, 862, 5, 67, 0, 0, 862, 863, 5, 79, 0, 0, 863, 864, 5, 78, 0, 0, 864, 865, 5, 84, 0, 0, 865, 866, 5, 65, 0, 0, 866, 867, 5, 73, 0, 0, 867, 868, 5, 78, 0, 0, 868, 870, 5, 83, 0, 0, 869, 847, 1, 0, 0, 0, 869, 858, 1, 0, 0, 0, 870, 108, 1, 0, 0, 0, 871, 872, 5, 115, 0, 0, 872, 873, 5, 116, 0, 0, 873, 874, 5, 95, 0, 0, 874, 875, 5, 105, 0, 0, 875, 876, 5, 110, 0, 0, 876, 877, 5, 116, 0, 0, 877, 878, 5, 101, 0, 0, 878, 879, 5, 114, 0, 0, 879, 880, 5, 115, 0, 0, 880, 881, 5, 101, 0, 0, 881, 882, 5, 99, 0, 0, 882, 883, 5, 116, 0, 0, 883, 898, 5, 115, 0, 0, 884, 885, 5, 83, 0, 0, 885, 886, 5, 84, 0, 0, 886, 887, 5, 95, 0, 0, 887, 888, 5, 73, 0, 0, 888, 889, 5, 78, 0, 0, 889, 890, 5, 84, 0, 0, 890, 891, 5, 69, 0, 0, 891, 892, 5, 82, 0, 0, 892, 893, 5, 83, 0, 0, 893, 894, 5, 69, 0, 0, 894, 895, 5, 67, 0, 0, 895, 896, 5, 84, 0, 0, 896, 898, 5, 83, 0, 0, 897, 871, 1, 0, 0, 0, 897, 884, 1, 0, 0, 0, 898, 110, 1, 0, 0, 0, 899, 900, 5, 115, 0, 0, 900, 901, 5, 116, 0, 0, 901, 902, 5, 95, 0, 0, 902, 903, 5, 119, 0, 0, 903, 904, 5, 105, 0, 0, 904, 905, 5, 116, 0, 0, 905, 906, 5, 104, 0, 0, 906, 907, 5, 105, 0, 0, 907, 918, 5, 110, 0, 0, 908, 909, 5, 83, 0, 0, 909, 910, 5, 84, 0, 0, 910, 911, 5, 95, 0, 0, 911, 912, 5, 87, 0, 0, 912, 913, 5, 73, 0, 0, 913, 914, 5, 84, 0, 0, 914, 915, 5, 72, 0, 0, 915, 916, 5, 73, 0, 0, 916, 918, 5, 78, 0, 0, 917, 899, 1, 0, 0, 0, 917, 908, 1, 0, 0, 0, 918, 112, 1, 0, 0, 0, 919, 920, 5, 115, 0, 0, 920, 921, 5, 116, 0, 0, 921, 922, 5, 95, 0, 0, 922, 923, 5, 100, 0, 0, 923, 924, 5, 119, 0, 0, 924, 925, 5, 105, 0, 0, 925, 926, 5, 116, 0, 0, 926, 927, 5, 104, 0, 0, 927, 928, 5, 105, 0, 0, 928, 940, 5, 110, 0, 0, 929, 930, 5, 83, 0, 0, 930, 931, 5, 84, 0, 0, 931, 932, 5, 95, 0, 0, 932, 933, 5, 68, 0, 0, 933, 934, 5, 87, 0, 0, 934, 935, 5, 73, 0, 0, 935, 936, 5, 84, 0, 0, 936, 937, 5, 72, 0, 0, 937, 938, 5, 73, 0, 0, 938, 940, 5, 78, 0, 0, 939, 919, 1, 0, 0, 0, 939, 929, 1, 0, 0, 0, 940, 114, 1, 0, 0, 0, 941, 942, 5, 115, 0, 0, 942, 943, 5, 116, 0, 0, 943, 944, 5, 95, 0, 0, 944, 945, 5, 105, 0, 0, 945, 946, 5, 115, 0, 0, 946, 947, 5, 118, 0, 0, 947, 948, 5, 97, 0, 0, 948, 949, 5, 108, 0, 0, 949, 950, 5, 105, 0, 0, 950, 962, 5, 100, 0, 0, 951, 952, 5, 83, 0, 0, 952, 953, 5, 84, 0, 0, 953, 954, 5, 95, 0, 0, 954, 955, 5, 73, 0, 0, 955, 956, 5, 83, 0, 0, 956, 957, 5, 86, 0, 0, 957, 958, 5, 65, 0, 0, 958, 959, 5, 76, 0, 0, 959, 960, 5, 73, 0, 0, 960, 962, 5, 68, 0, 0, 961, 941, 1, 0, 0, 0, 961, 951, 1, 0, 0, 0, 962, 116, 1, 0, 0, 0, 963, 964, 5, 116, 0, 0, 964, 965, 5, 114, 0, 0, 965, 966, 5, 117, 0, 0, 966, 991, 5, 101, 0, 0, 967, 968, 5, 84, 0, 0, 968, 969, 5, 114, 0, 0, 969, 970, 5, 117, 0, 0, 970, 991, 5, 101, 0, 0, 971, 972, 5, 84, 0, 0, 972, 973, 5, 82, 0, 0, 973, 974, 5, 85, 0, 0, 974, 991, 5, 69, 0, 0, 975, 976, 5, 102, 0, 0, 976, 977, 5, 97, 0, 0, 977, 978, 5, 108, 0, 0, 978, 979, 5, 115, 0, 0, 979, 991, 5, 101, 0, 0, 980, 981, 5, 70, 0, 0, 981, 982, 5, 97, 0, 0, 982, 983, 5, 108, 0, 0, 983, 984, 5, 115, 0, 0, 984, 991, 5, 101, 0, 0, 985, 986, 5, 70, 0, 0, 986, 987, 5, 65, 0, 0, 987, 988, 5, 76, 0, 0, 988, 989, 5, 83, 0, 0, 989, 991, 5, 69, 0, 0, 990, 963, 1, 0, 0, 0, 990, 967, 1, 0, 0, 0, 990, 971, 1, 0, 0, 0, 990, 975, 1, 0, 0, 0, 990, 980, 1, 0, 0, 0, 990, 985, 1, 0, 0, 0, 991, 118, 1, 0, 0, 0, 992, 997, 3, 149, 74, 0, 993, 997, 3, 151, 75, 0, 994, 997, 3, 153, 76, 0, 995, 997, 3, 147, 73, 0, 996, 992, 1, 0, 0, 0, 996, 993, 1, 0, 0, 0, 996, 994, 1, 0, 0, 0, 996, 995, 1, 0, 0, 0, 997, 120, 1, 0, 0, 0, 998, 1001, 3, 165, 82, 0, 999, 1001, 3, 167, 83, 0, 1000, 998, 1, 0, 0, 0, 1000, 999, 1, 0, 0, 0, 1001, 122, 1, 0, 0, 0, 1002, 1007, 3, 143, 71, 0, 1003, 1006, 3, 143, 71, 0, 1004, 1006, 3, 145, 72, 0, 1005, 1003, 1, 0, 0, 0, 1005, 1004, 1, 0, 0, 0, 1006, 1009, 1, 0, 0, 0, 1007, 1005, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 124, 1, 0, 0, 0, 1009, 1007, 1, 0, 0, 0, 1010, 1011, 5, 36, 0, 0, 1011, 1012, 5, 109, 0, 0, 1012, 1013, 5, 101, 0, 0, 1013, 1014, 5, 116, 0, 0, 1014, 1015, 5, 97, 0, 0, 1015, 126, 1, 0, 0, 0, 1016, 1018, 3, 133, 66, 0, 1017, 1016, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1029, 1, 0, 0, 0, 1019, 1021, 5, 34, 0, 0, 1020, 1022, 3, 135, 67, 0, 1021, 1020, 1, 0, 0, 0, 1021, 1022, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1030, 5, 34, 0, 0, 1024, 1026, 5, 39, 0, 0, 1025, 1027, 3, 137, 68, 0, 1026, 1025, 1, 0, 0, 0, 1026, 1027, 1, 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 1030, 5, 39, 0, 0, 1029, 1019, 1, 0, 0, 0, 1029, 1024, 1, 0, 0, 0, 1030, 128, 1, 0, 0, 0, 1031, 1034, 3, 123, 61, 0, 1032, 1034, 3, 125, 62, 0, 1033, 1031, 1, 0, 0, 0, 1033, 1032, 1, 0, 0, 0, 1034, 1042, 1, 0, 0, 0, 1035, 1038, 5, 91, 0, 0, 1036, 1039, 3, 127, 63, 0, 1037, 1039, 3, 149, 74, 0, 1038, 1036, 1, 0, 0, 0, 1038, 1037, 1, 0, 0, 0, 1039, 1040, 1, 0, 0, 0, 1040, 1041, 5, 93, 0, 0, 1041, 1043, 1, 0, 0, 0, 1042, 1035, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, 1042, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 130, 1, 0, 0, 0, 1046, 1047, 5, 36, 0, 0, 1047, 1048, 5, 91, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1050, 3, 123, 61, 0, 1050, 1051, 5, 93, 0, 0, 1051, 132, 1, 0, 0, 0, 1052, 1053, 5, 117, 0, 0, 1053, 1056, 5, 56, 0, 0, 1054, 1056, 7, 0, 0, 0, 1055, 1052, 1, 0, 0, 0, 1055, 1054, 1, 0, 0, 0, 1056, 134, 1, 0, 0, 0, 1057, 1059, 3, 139, 69, 0, 1058, 1057, 1, 0, 0, 0, 1059, 1060, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 136, 1, 0, 0, 0, 1062, 1064, 3, 141, 70, 0, 1063, 1062, 1, 0, 0, 0, 1064, 1065, 1, 0, 0, 0, 1065, 1063, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 138, 1, 0, 0, 0, 1067, 1075, 8, 1, 0, 0, 1068, 1075, 3, 181, 90, 0, 1069, 1070, 5, 92, 0, 0, 1070, 1075, 5, 10, 0, 0, 1071, 1072, 5, 92, 0, 0, 1072, 1073, 5, 13, 0, 0, 1073, 1075, 5, 10, 0, 0, 1074, 1067, 1, 0, 0, 0, 1074, 1068, 1, 0, 0, 0, 1074, 1069, 1, 0, 0, 0, 1074, 1071, 1, 0, 0, 0, 1075, 140, 1, 0, 0, 0, 1076, 1084, 8, 2, 0, 0, 1077, 1084, 3, 181, 90, 0, 1078, 1079, 5, 92, 0, 0, 1079, 1084, 5, 10, 0, 0, 1080, 1081, 5, 92, 0, 0, 1081, 1082, 5, 13, 0, 0, 1082, 1084, 5, 10, 0, 0, 1083, 1076, 1, 0, 0, 0, 1083, 1077, 1, 0, 0, 0, 1083, 1078, 1, 0, 0, 0, 1083, 1080, 1, 0, 0, 0, 1084, 142, 1, 0, 0, 0, 1085, 1086, 7, 3, 0, 0, 1086, 144, 1, 0, 0, 0, 1087, 1088, 7, 4, 0, 0, 1088, 146, 1, 0, 0, 0, 1089, 1090, 5, 48, 0, 0, 1090, 1092, 7, 5, 0, 0, 1091, 1093, 7, 6, 0, 0, 1092, 1091, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1092, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, 1095, 148, 1, 0, 0, 0, 1096, 1100, 3, 155, 77, 0, 1097, 1099, 3, 145, 72, 0, 1098, 1097, 1, 0, 0, 0, 1099, 1102, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1100, 1101, 1, 0, 0, 0, 1101, 1105, 1, 0, 0, 0, 1102, 1100, 1, 0, 0, 0, 1103, 1105, 5, 48, 0, 0, 1104, 1096, 1, 0, 0, 0, 1104, 1103, 1, 0, 0, 0, 1105, 150, 1, 0, 0, 0, 1106, 1110, 5, 48, 0, 0, 1107, 1109, 3, 157, 78, 0, 1108, 1107, 1, 0, 0, 0, 1109, 1112, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1110, 1111, 1, 0, 0, 0, 1111, 152, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1113, 1114, 5, 48, 0, 0, 1114, 1115, 7, 7, 0, 0, 1115, 1116, 3, 177, 88, 0, 1116, 154, 1, 0, 0, 0, 1117, 1118, 7, 8, 0, 0, 1118, 156, 1, 0, 0, 0, 1119, 1120, 7, 9, 0, 0, 1120, 158, 1, 0, 0, 0, 1121, 1122, 7, 10, 0, 0, 1122, 160, 1, 0, 0, 0, 1123, 1124, 3, 159, 79, 0, 1124, 1125, 3, 159, 79, 0, 1125, 1126, 3, 159, 79, 0, 1126, 1127, 3, 159, 79, 0, 1127, 162, 1, 0, 0, 0, 1128, 1129, 5, 92, 0, 0, 1129, 1130, 5, 117, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, 1139, 3, 161, 80, 0, 1132, 1133, 5, 92, 0, 0, 1133, 1134, 5, 85, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1136, 3, 161, 80, 0, 1136, 1137, 3, 161, 80, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1128, 1, 0, 0, 0, 1138, 1132, 1, 0, 0, 0, 1139, 164, 1, 0, 0, 0, 1140, 1142, 3, 169, 84, 0, 1141, 1143, 3, 171, 85, 0, 1142, 1141, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1148, 1, 0, 0, 0, 1144, 1145, 3, 173, 86, 0, 1145, 1146, 3, 171, 85, 0, 1146, 1148, 1, 0, 0, 0, 1147, 1140, 1, 0, 0, 0, 1147, 1144, 1, 0, 0, 0, 1148, 166, 1, 0, 0, 0, 1149, 1150, 5, 48, 0, 0, 1150, 1153, 7, 7, 0, 0, 1151, 1154, 3, 175, 87, 0, 1152, 1154, 3, 177, 88, 0, 1153, 1151, 1, 0, 0, 0, 1153, 1152, 1, 0, 0, 0, 1154, 1155, 1, 0, 0, 0, 1155, 1156, 3, 179, 89, 0, 1156, 168, 1, 0, 0, 0, 1157, 1159, 3, 173, 86, 0, 1158, 1157, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1161, 5, 46, 0, 0, 1161, 1166, 3, 173, 86, 0, 1162, 1163, 3, 173, 86, 0, 1163, 1164, 5, 46, 0, 0, 1164, 1166, 1, 0, 0, 0, 1165, 1158, 1, 0, 0, 0, 1165, 1162, 1, 0, 0, 0, 1166, 170, 1, 0, 0, 0, 1167, 1169, 7, 11, 0, 0, 1168, 1170, 7, 12, 0, 0, 1169, 1168, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 1172, 3, 173, 86, 0, 1172, 172, 1, 0, 0, 0, 1173, 1175, 3, 145, 72, 0, 1174, 1173, 1, 0, 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1174, 1, 0, 0, 0, 1176, 1177, 1, 0, 0, 0, 1177, 174, 1, 0, 0, 0, 1178, 1180, 3, 177, 88, 0, 1179, 1178, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, 1182, 5, 46, 0, 0, 1182, 1187, 3, 177, 88, 0, 1183, 1184, 3, 177, 88, 0, 1184, 1185, 5, 46, 0, 0, 1185, 1187, 1, 0, 0, 0, 1186, 1179, 1, 0, 0, 0, 1186, 1183, 1, 0, 0, 0, 1187, 176, 1, 0, 0, 0, 1188, 1190, 3, 159, 79, 0, 1189, 1188, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1189, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 178, 1, 0, 0, 0, 1193, 1195, 7, 13, 0, 0, 1194, 1196, 7, 12, 0, 0, 1195, 1194, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1197, 1, 0, 0, 0, 1197, 1198, 3, 173, 86, 0, 1198, 180, 1, 0, 0, 0, 1199, 1200, 5, 92, 0, 0, 1200, 1215, 7, 14, 0, 0, 1201, 1202, 5, 92, 0, 0, 1202, 1204, 3, 157, 78, 0, 1203, 1205, 3, 157, 78, 0, 1204, 1203, 1, 0, 0, 0, 1204, 1205, 1, 0, 0, 0, 1205, 1207, 1, 0, 0, 0, 1206, 1208, 3, 157, 78, 0, 1207, 1206, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1215, 1, 0, 0, 0, 1209, 1210, 5, 92, 0, 0, 1210, 1211, 5, 120, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1215, 3, 177, 88, 0, 1213, 1215, 3, 163, 81, 0, 1214, 1199, 1, 0, 0, 0, 1214, 1201, 1, 0, 0, 0, 1214, 1209, 1, 0, 0, 0, 1214, 1213, 1, 0, 0, 0, 1215, 182, 1, 0, 0, 0, 1216, 1218, 7, 15, 0, 0, 1217, 1216, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1219, 1220, 1, 0, 0, 0, 1220, 1221, 1, 0, 0, 0, 1221, 1222, 6, 91, 0, 0, 1222, 184, 1, 0, 0, 0, 1223, 1225, 5, 13, 0, 0, 1224, 1226, 5, 10, 0, 0, 1225, 1224, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 1229, 1, 0, 0, 0, 1227, 1229, 5, 10, 0, 0, 1228, 1223, 1, 0, 0, 0, 1228, 1227, 1, 0, 0, 0, 1229, 1230, 1, 0, 0, 0, 1230, 1231, 6, 92, 0, 0, 1231, 186, 1, 0, 0, 0, 73, 0, 225, 239, 261, 287, 315, 333, 341, 383, 420, 428, 444, 468, 479, 485, 490, 492, 523, 559, 595, 625, 663, 701, 727, 757, 777, 799, 823, 845, 869, 897, 917, 939, 961, 990, 996, 1000, 1005, 1007, 1017, 1021, 1026, 1029, 1033, 1038, 1044, 1055, 1060, 1065, 1074, 1083, 1094, 1100, 1104, 1110, 1138, 1142, 1147, 1153, 1158, 1165, 1169, 1176, 1179, 1186, 1191, 1195, 1204, 1207, 1214, 1219, 1225, 1228, 1, 6, 0, 0] \ No newline at end of file +[4, 0, 74, 1374, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 238, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 252, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 274, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 300, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 328, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 348, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 368, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 392, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 414, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 438, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 456, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 464, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 506, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 526, 8, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 563, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 571, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 587, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 611, 8, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 622, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 628, 8, 45, 1, 46, 1, 46, 1, 46, 5, 46, 633, 8, 46, 10, 46, 12, 46, 636, 9, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 666, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 702, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 738, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 768, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 806, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 844, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 870, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 900, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 920, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 942, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 966, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 988, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1012, 8, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1040, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1060, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1082, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1104, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1133, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1139, 8, 65, 1, 66, 1, 66, 3, 66, 1143, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1148, 8, 67, 10, 67, 12, 67, 1151, 9, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 3, 69, 1160, 8, 69, 1, 69, 1, 69, 3, 69, 1164, 8, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1169, 8, 69, 1, 69, 3, 69, 1172, 8, 69, 1, 70, 1, 70, 3, 70, 1176, 8, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1181, 8, 70, 1, 70, 1, 70, 4, 70, 1185, 8, 70, 11, 70, 12, 70, 1186, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 3, 72, 1198, 8, 72, 1, 73, 4, 73, 1201, 8, 73, 11, 73, 12, 73, 1202, 1, 74, 4, 74, 1206, 8, 74, 11, 74, 12, 74, 1207, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1217, 8, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1226, 8, 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 4, 79, 1235, 8, 79, 11, 79, 12, 79, 1236, 1, 80, 1, 80, 5, 80, 1241, 8, 80, 10, 80, 12, 80, 1244, 9, 80, 1, 80, 3, 80, 1247, 8, 80, 1, 81, 1, 81, 5, 81, 1251, 8, 81, 10, 81, 12, 81, 1254, 9, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1281, 8, 87, 1, 88, 1, 88, 3, 88, 1285, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1290, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1296, 8, 89, 1, 89, 1, 89, 1, 90, 3, 90, 1301, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1308, 8, 90, 1, 91, 1, 91, 3, 91, 1312, 8, 91, 1, 91, 1, 91, 1, 92, 4, 92, 1317, 8, 92, 11, 92, 12, 92, 1318, 1, 93, 3, 93, 1322, 8, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1329, 8, 93, 1, 94, 4, 94, 1332, 8, 94, 11, 94, 12, 94, 1333, 1, 95, 1, 95, 3, 95, 1338, 8, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1347, 8, 96, 1, 96, 3, 96, 1350, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1357, 8, 96, 1, 97, 4, 97, 1360, 8, 97, 11, 97, 12, 97, 1361, 1, 97, 1, 97, 1, 98, 1, 98, 3, 98, 1368, 8, 98, 1, 98, 3, 98, 1371, 8, 98, 1, 98, 1, 98, 0, 0, 99, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 0, 147, 0, 149, 0, 151, 0, 153, 0, 155, 0, 157, 0, 159, 0, 161, 0, 163, 0, 165, 0, 167, 0, 169, 0, 171, 0, 173, 0, 175, 0, 177, 0, 179, 0, 181, 0, 183, 0, 185, 0, 187, 0, 189, 0, 191, 0, 193, 0, 195, 73, 197, 74, 1, 0, 16, 3, 0, 76, 76, 85, 85, 117, 117, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 3, 0, 65, 90, 95, 95, 97, 122, 1, 0, 48, 57, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 2, 0, 88, 88, 120, 120, 1, 0, 49, 57, 1, 0, 48, 55, 3, 0, 48, 57, 65, 70, 97, 102, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 80, 80, 112, 112, 10, 0, 34, 34, 39, 39, 63, 63, 92, 92, 97, 98, 102, 102, 110, 110, 114, 114, 116, 116, 118, 118, 2, 0, 9, 9, 32, 32, 1441, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 1, 199, 1, 0, 0, 0, 3, 201, 1, 0, 0, 0, 5, 203, 1, 0, 0, 0, 7, 205, 1, 0, 0, 0, 9, 207, 1, 0, 0, 0, 11, 209, 1, 0, 0, 0, 13, 211, 1, 0, 0, 0, 15, 213, 1, 0, 0, 0, 17, 215, 1, 0, 0, 0, 19, 218, 1, 0, 0, 0, 21, 220, 1, 0, 0, 0, 23, 223, 1, 0, 0, 0, 25, 226, 1, 0, 0, 0, 27, 237, 1, 0, 0, 0, 29, 251, 1, 0, 0, 0, 31, 273, 1, 0, 0, 0, 33, 299, 1, 0, 0, 0, 35, 327, 1, 0, 0, 0, 37, 347, 1, 0, 0, 0, 39, 367, 1, 0, 0, 0, 41, 391, 1, 0, 0, 0, 43, 413, 1, 0, 0, 0, 45, 437, 1, 0, 0, 0, 47, 455, 1, 0, 0, 0, 49, 463, 1, 0, 0, 0, 51, 505, 1, 0, 0, 0, 53, 525, 1, 0, 0, 0, 55, 527, 1, 0, 0, 0, 57, 529, 1, 0, 0, 0, 59, 531, 1, 0, 0, 0, 61, 533, 1, 0, 0, 0, 63, 535, 1, 0, 0, 0, 65, 537, 1, 0, 0, 0, 67, 539, 1, 0, 0, 0, 69, 542, 1, 0, 0, 0, 71, 545, 1, 0, 0, 0, 73, 548, 1, 0, 0, 0, 75, 550, 1, 0, 0, 0, 77, 552, 1, 0, 0, 0, 79, 562, 1, 0, 0, 0, 81, 570, 1, 0, 0, 0, 83, 586, 1, 0, 0, 0, 85, 610, 1, 0, 0, 0, 87, 612, 1, 0, 0, 0, 89, 621, 1, 0, 0, 0, 91, 627, 1, 0, 0, 0, 93, 629, 1, 0, 0, 0, 95, 665, 1, 0, 0, 0, 97, 701, 1, 0, 0, 0, 99, 737, 1, 0, 0, 0, 101, 767, 1, 0, 0, 0, 103, 805, 1, 0, 0, 0, 105, 843, 1, 0, 0, 0, 107, 869, 1, 0, 0, 0, 109, 899, 1, 0, 0, 0, 111, 919, 1, 0, 0, 0, 113, 941, 1, 0, 0, 0, 115, 965, 1, 0, 0, 0, 117, 987, 1, 0, 0, 0, 119, 1011, 1, 0, 0, 0, 121, 1039, 1, 0, 0, 0, 123, 1059, 1, 0, 0, 0, 125, 1081, 1, 0, 0, 0, 127, 1103, 1, 0, 0, 0, 129, 1132, 1, 0, 0, 0, 131, 1138, 1, 0, 0, 0, 133, 1142, 1, 0, 0, 0, 135, 1144, 1, 0, 0, 0, 137, 1152, 1, 0, 0, 0, 139, 1159, 1, 0, 0, 0, 141, 1175, 1, 0, 0, 0, 143, 1188, 1, 0, 0, 0, 145, 1197, 1, 0, 0, 0, 147, 1200, 1, 0, 0, 0, 149, 1205, 1, 0, 0, 0, 151, 1216, 1, 0, 0, 0, 153, 1225, 1, 0, 0, 0, 155, 1227, 1, 0, 0, 0, 157, 1229, 1, 0, 0, 0, 159, 1231, 1, 0, 0, 0, 161, 1246, 1, 0, 0, 0, 163, 1248, 1, 0, 0, 0, 165, 1255, 1, 0, 0, 0, 167, 1259, 1, 0, 0, 0, 169, 1261, 1, 0, 0, 0, 171, 1263, 1, 0, 0, 0, 173, 1265, 1, 0, 0, 0, 175, 1280, 1, 0, 0, 0, 177, 1289, 1, 0, 0, 0, 179, 1291, 1, 0, 0, 0, 181, 1307, 1, 0, 0, 0, 183, 1309, 1, 0, 0, 0, 185, 1316, 1, 0, 0, 0, 187, 1328, 1, 0, 0, 0, 189, 1331, 1, 0, 0, 0, 191, 1335, 1, 0, 0, 0, 193, 1356, 1, 0, 0, 0, 195, 1359, 1, 0, 0, 0, 197, 1370, 1, 0, 0, 0, 199, 200, 5, 40, 0, 0, 200, 2, 1, 0, 0, 0, 201, 202, 5, 41, 0, 0, 202, 4, 1, 0, 0, 0, 203, 204, 5, 91, 0, 0, 204, 6, 1, 0, 0, 0, 205, 206, 5, 44, 0, 0, 206, 8, 1, 0, 0, 0, 207, 208, 5, 93, 0, 0, 208, 10, 1, 0, 0, 0, 209, 210, 5, 123, 0, 0, 210, 12, 1, 0, 0, 0, 211, 212, 5, 125, 0, 0, 212, 14, 1, 0, 0, 0, 213, 214, 5, 60, 0, 0, 214, 16, 1, 0, 0, 0, 215, 216, 5, 60, 0, 0, 216, 217, 5, 61, 0, 0, 217, 18, 1, 0, 0, 0, 218, 219, 5, 62, 0, 0, 219, 20, 1, 0, 0, 0, 220, 221, 5, 62, 0, 0, 221, 222, 5, 61, 0, 0, 222, 22, 1, 0, 0, 0, 223, 224, 5, 61, 0, 0, 224, 225, 5, 61, 0, 0, 225, 24, 1, 0, 0, 0, 226, 227, 5, 33, 0, 0, 227, 228, 5, 61, 0, 0, 228, 26, 1, 0, 0, 0, 229, 230, 5, 108, 0, 0, 230, 231, 5, 105, 0, 0, 231, 232, 5, 107, 0, 0, 232, 238, 5, 101, 0, 0, 233, 234, 5, 76, 0, 0, 234, 235, 5, 73, 0, 0, 235, 236, 5, 75, 0, 0, 236, 238, 5, 69, 0, 0, 237, 229, 1, 0, 0, 0, 237, 233, 1, 0, 0, 0, 238, 28, 1, 0, 0, 0, 239, 240, 5, 101, 0, 0, 240, 241, 5, 120, 0, 0, 241, 242, 5, 105, 0, 0, 242, 243, 5, 115, 0, 0, 243, 244, 5, 116, 0, 0, 244, 252, 5, 115, 0, 0, 245, 246, 5, 69, 0, 0, 246, 247, 5, 88, 0, 0, 247, 248, 5, 73, 0, 0, 248, 249, 5, 83, 0, 0, 249, 250, 5, 84, 0, 0, 250, 252, 5, 83, 0, 0, 251, 239, 1, 0, 0, 0, 251, 245, 1, 0, 0, 0, 252, 30, 1, 0, 0, 0, 253, 254, 5, 116, 0, 0, 254, 255, 5, 101, 0, 0, 255, 256, 5, 120, 0, 0, 256, 257, 5, 116, 0, 0, 257, 258, 5, 95, 0, 0, 258, 259, 5, 109, 0, 0, 259, 260, 5, 97, 0, 0, 260, 261, 5, 116, 0, 0, 261, 262, 5, 99, 0, 0, 262, 274, 5, 104, 0, 0, 263, 264, 5, 84, 0, 0, 264, 265, 5, 69, 0, 0, 265, 266, 5, 88, 0, 0, 266, 267, 5, 84, 0, 0, 267, 268, 5, 95, 0, 0, 268, 269, 5, 77, 0, 0, 269, 270, 5, 65, 0, 0, 270, 271, 5, 84, 0, 0, 271, 272, 5, 67, 0, 0, 272, 274, 5, 72, 0, 0, 273, 253, 1, 0, 0, 0, 273, 263, 1, 0, 0, 0, 274, 32, 1, 0, 0, 0, 275, 276, 5, 112, 0, 0, 276, 277, 5, 104, 0, 0, 277, 278, 5, 114, 0, 0, 278, 279, 5, 97, 0, 0, 279, 280, 5, 115, 0, 0, 280, 281, 5, 101, 0, 0, 281, 282, 5, 95, 0, 0, 282, 283, 5, 109, 0, 0, 283, 284, 5, 97, 0, 0, 284, 285, 5, 116, 0, 0, 285, 286, 5, 99, 0, 0, 286, 300, 5, 104, 0, 0, 287, 288, 5, 80, 0, 0, 288, 289, 5, 72, 0, 0, 289, 290, 5, 82, 0, 0, 290, 291, 5, 65, 0, 0, 291, 292, 5, 83, 0, 0, 292, 293, 5, 69, 0, 0, 293, 294, 5, 95, 0, 0, 294, 295, 5, 77, 0, 0, 295, 296, 5, 65, 0, 0, 296, 297, 5, 84, 0, 0, 297, 298, 5, 67, 0, 0, 298, 300, 5, 72, 0, 0, 299, 275, 1, 0, 0, 0, 299, 287, 1, 0, 0, 0, 300, 34, 1, 0, 0, 0, 301, 302, 5, 114, 0, 0, 302, 303, 5, 97, 0, 0, 303, 304, 5, 110, 0, 0, 304, 305, 5, 100, 0, 0, 305, 306, 5, 111, 0, 0, 306, 307, 5, 109, 0, 0, 307, 308, 5, 95, 0, 0, 308, 309, 5, 115, 0, 0, 309, 310, 5, 97, 0, 0, 310, 311, 5, 109, 0, 0, 311, 312, 5, 112, 0, 0, 312, 313, 5, 108, 0, 0, 313, 328, 5, 101, 0, 0, 314, 315, 5, 82, 0, 0, 315, 316, 5, 65, 0, 0, 316, 317, 5, 78, 0, 0, 317, 318, 5, 68, 0, 0, 318, 319, 5, 79, 0, 0, 319, 320, 5, 77, 0, 0, 320, 321, 5, 95, 0, 0, 321, 322, 5, 83, 0, 0, 322, 323, 5, 65, 0, 0, 323, 324, 5, 77, 0, 0, 324, 325, 5, 80, 0, 0, 325, 326, 5, 76, 0, 0, 326, 328, 5, 69, 0, 0, 327, 301, 1, 0, 0, 0, 327, 314, 1, 0, 0, 0, 328, 36, 1, 0, 0, 0, 329, 330, 5, 109, 0, 0, 330, 331, 5, 97, 0, 0, 331, 332, 5, 116, 0, 0, 332, 333, 5, 99, 0, 0, 333, 334, 5, 104, 0, 0, 334, 335, 5, 95, 0, 0, 335, 336, 5, 97, 0, 0, 336, 337, 5, 108, 0, 0, 337, 348, 5, 108, 0, 0, 338, 339, 5, 77, 0, 0, 339, 340, 5, 65, 0, 0, 340, 341, 5, 84, 0, 0, 341, 342, 5, 67, 0, 0, 342, 343, 5, 72, 0, 0, 343, 344, 5, 95, 0, 0, 344, 345, 5, 65, 0, 0, 345, 346, 5, 76, 0, 0, 346, 348, 5, 76, 0, 0, 347, 329, 1, 0, 0, 0, 347, 338, 1, 0, 0, 0, 348, 38, 1, 0, 0, 0, 349, 350, 5, 109, 0, 0, 350, 351, 5, 97, 0, 0, 351, 352, 5, 116, 0, 0, 352, 353, 5, 99, 0, 0, 353, 354, 5, 104, 0, 0, 354, 355, 5, 95, 0, 0, 355, 356, 5, 97, 0, 0, 356, 357, 5, 110, 0, 0, 357, 368, 5, 121, 0, 0, 358, 359, 5, 77, 0, 0, 359, 360, 5, 65, 0, 0, 360, 361, 5, 84, 0, 0, 361, 362, 5, 67, 0, 0, 362, 363, 5, 72, 0, 0, 363, 364, 5, 95, 0, 0, 364, 365, 5, 65, 0, 0, 365, 366, 5, 78, 0, 0, 366, 368, 5, 89, 0, 0, 367, 349, 1, 0, 0, 0, 367, 358, 1, 0, 0, 0, 368, 40, 1, 0, 0, 0, 369, 370, 5, 109, 0, 0, 370, 371, 5, 97, 0, 0, 371, 372, 5, 116, 0, 0, 372, 373, 5, 99, 0, 0, 373, 374, 5, 104, 0, 0, 374, 375, 5, 95, 0, 0, 375, 376, 5, 108, 0, 0, 376, 377, 5, 101, 0, 0, 377, 378, 5, 97, 0, 0, 378, 379, 5, 115, 0, 0, 379, 392, 5, 116, 0, 0, 380, 381, 5, 77, 0, 0, 381, 382, 5, 65, 0, 0, 382, 383, 5, 84, 0, 0, 383, 384, 5, 67, 0, 0, 384, 385, 5, 72, 0, 0, 385, 386, 5, 95, 0, 0, 386, 387, 5, 76, 0, 0, 387, 388, 5, 69, 0, 0, 388, 389, 5, 65, 0, 0, 389, 390, 5, 83, 0, 0, 390, 392, 5, 84, 0, 0, 391, 369, 1, 0, 0, 0, 391, 380, 1, 0, 0, 0, 392, 42, 1, 0, 0, 0, 393, 394, 5, 109, 0, 0, 394, 395, 5, 97, 0, 0, 395, 396, 5, 116, 0, 0, 396, 397, 5, 99, 0, 0, 397, 398, 5, 104, 0, 0, 398, 399, 5, 95, 0, 0, 399, 400, 5, 109, 0, 0, 400, 401, 5, 111, 0, 0, 401, 402, 5, 115, 0, 0, 402, 414, 5, 116, 0, 0, 403, 404, 5, 77, 0, 0, 404, 405, 5, 65, 0, 0, 405, 406, 5, 84, 0, 0, 406, 407, 5, 67, 0, 0, 407, 408, 5, 72, 0, 0, 408, 409, 5, 95, 0, 0, 409, 410, 5, 77, 0, 0, 410, 411, 5, 79, 0, 0, 411, 412, 5, 83, 0, 0, 412, 414, 5, 84, 0, 0, 413, 393, 1, 0, 0, 0, 413, 403, 1, 0, 0, 0, 414, 44, 1, 0, 0, 0, 415, 416, 5, 109, 0, 0, 416, 417, 5, 97, 0, 0, 417, 418, 5, 116, 0, 0, 418, 419, 5, 99, 0, 0, 419, 420, 5, 104, 0, 0, 420, 421, 5, 95, 0, 0, 421, 422, 5, 101, 0, 0, 422, 423, 5, 120, 0, 0, 423, 424, 5, 97, 0, 0, 424, 425, 5, 99, 0, 0, 425, 438, 5, 116, 0, 0, 426, 427, 5, 77, 0, 0, 427, 428, 5, 65, 0, 0, 428, 429, 5, 84, 0, 0, 429, 430, 5, 67, 0, 0, 430, 431, 5, 72, 0, 0, 431, 432, 5, 95, 0, 0, 432, 433, 5, 69, 0, 0, 433, 434, 5, 88, 0, 0, 434, 435, 5, 65, 0, 0, 435, 436, 5, 67, 0, 0, 436, 438, 5, 84, 0, 0, 437, 415, 1, 0, 0, 0, 437, 426, 1, 0, 0, 0, 438, 46, 1, 0, 0, 0, 439, 440, 5, 105, 0, 0, 440, 441, 5, 110, 0, 0, 441, 442, 5, 116, 0, 0, 442, 443, 5, 101, 0, 0, 443, 444, 5, 114, 0, 0, 444, 445, 5, 118, 0, 0, 445, 446, 5, 97, 0, 0, 446, 456, 5, 108, 0, 0, 447, 448, 5, 73, 0, 0, 448, 449, 5, 78, 0, 0, 449, 450, 5, 84, 0, 0, 450, 451, 5, 69, 0, 0, 451, 452, 5, 82, 0, 0, 452, 453, 5, 86, 0, 0, 453, 454, 5, 65, 0, 0, 454, 456, 5, 76, 0, 0, 455, 439, 1, 0, 0, 0, 455, 447, 1, 0, 0, 0, 456, 48, 1, 0, 0, 0, 457, 458, 5, 105, 0, 0, 458, 459, 5, 115, 0, 0, 459, 464, 5, 111, 0, 0, 460, 461, 5, 73, 0, 0, 461, 462, 5, 83, 0, 0, 462, 464, 5, 79, 0, 0, 463, 457, 1, 0, 0, 0, 463, 460, 1, 0, 0, 0, 464, 50, 1, 0, 0, 0, 465, 466, 5, 109, 0, 0, 466, 467, 5, 105, 0, 0, 467, 468, 5, 110, 0, 0, 468, 469, 5, 105, 0, 0, 469, 470, 5, 109, 0, 0, 470, 471, 5, 117, 0, 0, 471, 472, 5, 109, 0, 0, 472, 473, 5, 95, 0, 0, 473, 474, 5, 115, 0, 0, 474, 475, 5, 104, 0, 0, 475, 476, 5, 111, 0, 0, 476, 477, 5, 117, 0, 0, 477, 478, 5, 108, 0, 0, 478, 479, 5, 100, 0, 0, 479, 480, 5, 95, 0, 0, 480, 481, 5, 109, 0, 0, 481, 482, 5, 97, 0, 0, 482, 483, 5, 116, 0, 0, 483, 484, 5, 99, 0, 0, 484, 506, 5, 104, 0, 0, 485, 486, 5, 77, 0, 0, 486, 487, 5, 73, 0, 0, 487, 488, 5, 78, 0, 0, 488, 489, 5, 73, 0, 0, 489, 490, 5, 77, 0, 0, 490, 491, 5, 85, 0, 0, 491, 492, 5, 77, 0, 0, 492, 493, 5, 95, 0, 0, 493, 494, 5, 83, 0, 0, 494, 495, 5, 72, 0, 0, 495, 496, 5, 79, 0, 0, 496, 497, 5, 85, 0, 0, 497, 498, 5, 76, 0, 0, 498, 499, 5, 68, 0, 0, 499, 500, 5, 95, 0, 0, 500, 501, 5, 77, 0, 0, 501, 502, 5, 65, 0, 0, 502, 503, 5, 84, 0, 0, 503, 504, 5, 67, 0, 0, 504, 506, 5, 72, 0, 0, 505, 465, 1, 0, 0, 0, 505, 485, 1, 0, 0, 0, 506, 52, 1, 0, 0, 0, 507, 508, 5, 116, 0, 0, 508, 509, 5, 104, 0, 0, 509, 510, 5, 114, 0, 0, 510, 511, 5, 101, 0, 0, 511, 512, 5, 115, 0, 0, 512, 513, 5, 104, 0, 0, 513, 514, 5, 111, 0, 0, 514, 515, 5, 108, 0, 0, 515, 526, 5, 100, 0, 0, 516, 517, 5, 84, 0, 0, 517, 518, 5, 72, 0, 0, 518, 519, 5, 82, 0, 0, 519, 520, 5, 69, 0, 0, 520, 521, 5, 83, 0, 0, 521, 522, 5, 72, 0, 0, 522, 523, 5, 79, 0, 0, 523, 524, 5, 76, 0, 0, 524, 526, 5, 68, 0, 0, 525, 507, 1, 0, 0, 0, 525, 516, 1, 0, 0, 0, 526, 54, 1, 0, 0, 0, 527, 528, 5, 61, 0, 0, 528, 56, 1, 0, 0, 0, 529, 530, 5, 43, 0, 0, 530, 58, 1, 0, 0, 0, 531, 532, 5, 45, 0, 0, 532, 60, 1, 0, 0, 0, 533, 534, 5, 42, 0, 0, 534, 62, 1, 0, 0, 0, 535, 536, 5, 47, 0, 0, 536, 64, 1, 0, 0, 0, 537, 538, 5, 37, 0, 0, 538, 66, 1, 0, 0, 0, 539, 540, 5, 42, 0, 0, 540, 541, 5, 42, 0, 0, 541, 68, 1, 0, 0, 0, 542, 543, 5, 60, 0, 0, 543, 544, 5, 60, 0, 0, 544, 70, 1, 0, 0, 0, 545, 546, 5, 62, 0, 0, 546, 547, 5, 62, 0, 0, 547, 72, 1, 0, 0, 0, 548, 549, 5, 38, 0, 0, 549, 74, 1, 0, 0, 0, 550, 551, 5, 124, 0, 0, 551, 76, 1, 0, 0, 0, 552, 553, 5, 94, 0, 0, 553, 78, 1, 0, 0, 0, 554, 555, 5, 38, 0, 0, 555, 563, 5, 38, 0, 0, 556, 557, 5, 97, 0, 0, 557, 558, 5, 110, 0, 0, 558, 563, 5, 100, 0, 0, 559, 560, 5, 65, 0, 0, 560, 561, 5, 78, 0, 0, 561, 563, 5, 68, 0, 0, 562, 554, 1, 0, 0, 0, 562, 556, 1, 0, 0, 0, 562, 559, 1, 0, 0, 0, 563, 80, 1, 0, 0, 0, 564, 565, 5, 124, 0, 0, 565, 571, 5, 124, 0, 0, 566, 567, 5, 111, 0, 0, 567, 571, 5, 114, 0, 0, 568, 569, 5, 79, 0, 0, 569, 571, 5, 82, 0, 0, 570, 564, 1, 0, 0, 0, 570, 566, 1, 0, 0, 0, 570, 568, 1, 0, 0, 0, 571, 82, 1, 0, 0, 0, 572, 573, 5, 105, 0, 0, 573, 574, 5, 115, 0, 0, 574, 575, 5, 32, 0, 0, 575, 576, 5, 110, 0, 0, 576, 577, 5, 117, 0, 0, 577, 578, 5, 108, 0, 0, 578, 587, 5, 108, 0, 0, 579, 580, 5, 73, 0, 0, 580, 581, 5, 83, 0, 0, 581, 582, 5, 32, 0, 0, 582, 583, 5, 78, 0, 0, 583, 584, 5, 85, 0, 0, 584, 585, 5, 76, 0, 0, 585, 587, 5, 76, 0, 0, 586, 572, 1, 0, 0, 0, 586, 579, 1, 0, 0, 0, 587, 84, 1, 0, 0, 0, 588, 589, 5, 105, 0, 0, 589, 590, 5, 115, 0, 0, 590, 591, 5, 32, 0, 0, 591, 592, 5, 110, 0, 0, 592, 593, 5, 111, 0, 0, 593, 594, 5, 116, 0, 0, 594, 595, 5, 32, 0, 0, 595, 596, 5, 110, 0, 0, 596, 597, 5, 117, 0, 0, 597, 598, 5, 108, 0, 0, 598, 611, 5, 108, 0, 0, 599, 600, 5, 73, 0, 0, 600, 601, 5, 83, 0, 0, 601, 602, 5, 32, 0, 0, 602, 603, 5, 78, 0, 0, 603, 604, 5, 79, 0, 0, 604, 605, 5, 84, 0, 0, 605, 606, 5, 32, 0, 0, 606, 607, 5, 78, 0, 0, 607, 608, 5, 85, 0, 0, 608, 609, 5, 76, 0, 0, 609, 611, 5, 76, 0, 0, 610, 588, 1, 0, 0, 0, 610, 599, 1, 0, 0, 0, 611, 86, 1, 0, 0, 0, 612, 613, 5, 126, 0, 0, 613, 88, 1, 0, 0, 0, 614, 622, 5, 33, 0, 0, 615, 616, 5, 110, 0, 0, 616, 617, 5, 111, 0, 0, 617, 622, 5, 116, 0, 0, 618, 619, 5, 78, 0, 0, 619, 620, 5, 79, 0, 0, 620, 622, 5, 84, 0, 0, 621, 614, 1, 0, 0, 0, 621, 615, 1, 0, 0, 0, 621, 618, 1, 0, 0, 0, 622, 90, 1, 0, 0, 0, 623, 624, 5, 105, 0, 0, 624, 628, 5, 110, 0, 0, 625, 626, 5, 73, 0, 0, 626, 628, 5, 78, 0, 0, 627, 623, 1, 0, 0, 0, 627, 625, 1, 0, 0, 0, 628, 92, 1, 0, 0, 0, 629, 634, 5, 91, 0, 0, 630, 633, 3, 195, 97, 0, 631, 633, 3, 197, 98, 0, 632, 630, 1, 0, 0, 0, 632, 631, 1, 0, 0, 0, 633, 636, 1, 0, 0, 0, 634, 632, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 637, 1, 0, 0, 0, 636, 634, 1, 0, 0, 0, 637, 638, 5, 93, 0, 0, 638, 94, 1, 0, 0, 0, 639, 640, 5, 106, 0, 0, 640, 641, 5, 115, 0, 0, 641, 642, 5, 111, 0, 0, 642, 643, 5, 110, 0, 0, 643, 644, 5, 95, 0, 0, 644, 645, 5, 99, 0, 0, 645, 646, 5, 111, 0, 0, 646, 647, 5, 110, 0, 0, 647, 648, 5, 116, 0, 0, 648, 649, 5, 97, 0, 0, 649, 650, 5, 105, 0, 0, 650, 651, 5, 110, 0, 0, 651, 666, 5, 115, 0, 0, 652, 653, 5, 74, 0, 0, 653, 654, 5, 83, 0, 0, 654, 655, 5, 79, 0, 0, 655, 656, 5, 78, 0, 0, 656, 657, 5, 95, 0, 0, 657, 658, 5, 67, 0, 0, 658, 659, 5, 79, 0, 0, 659, 660, 5, 78, 0, 0, 660, 661, 5, 84, 0, 0, 661, 662, 5, 65, 0, 0, 662, 663, 5, 73, 0, 0, 663, 664, 5, 78, 0, 0, 664, 666, 5, 83, 0, 0, 665, 639, 1, 0, 0, 0, 665, 652, 1, 0, 0, 0, 666, 96, 1, 0, 0, 0, 667, 668, 5, 106, 0, 0, 668, 669, 5, 115, 0, 0, 669, 670, 5, 111, 0, 0, 670, 671, 5, 110, 0, 0, 671, 672, 5, 95, 0, 0, 672, 673, 5, 99, 0, 0, 673, 674, 5, 111, 0, 0, 674, 675, 5, 110, 0, 0, 675, 676, 5, 116, 0, 0, 676, 677, 5, 97, 0, 0, 677, 678, 5, 105, 0, 0, 678, 679, 5, 110, 0, 0, 679, 680, 5, 115, 0, 0, 680, 681, 5, 95, 0, 0, 681, 682, 5, 97, 0, 0, 682, 683, 5, 108, 0, 0, 683, 702, 5, 108, 0, 0, 684, 685, 5, 74, 0, 0, 685, 686, 5, 83, 0, 0, 686, 687, 5, 79, 0, 0, 687, 688, 5, 78, 0, 0, 688, 689, 5, 95, 0, 0, 689, 690, 5, 67, 0, 0, 690, 691, 5, 79, 0, 0, 691, 692, 5, 78, 0, 0, 692, 693, 5, 84, 0, 0, 693, 694, 5, 65, 0, 0, 694, 695, 5, 73, 0, 0, 695, 696, 5, 78, 0, 0, 696, 697, 5, 83, 0, 0, 697, 698, 5, 95, 0, 0, 698, 699, 5, 65, 0, 0, 699, 700, 5, 76, 0, 0, 700, 702, 5, 76, 0, 0, 701, 667, 1, 0, 0, 0, 701, 684, 1, 0, 0, 0, 702, 98, 1, 0, 0, 0, 703, 704, 5, 106, 0, 0, 704, 705, 5, 115, 0, 0, 705, 706, 5, 111, 0, 0, 706, 707, 5, 110, 0, 0, 707, 708, 5, 95, 0, 0, 708, 709, 5, 99, 0, 0, 709, 710, 5, 111, 0, 0, 710, 711, 5, 110, 0, 0, 711, 712, 5, 116, 0, 0, 712, 713, 5, 97, 0, 0, 713, 714, 5, 105, 0, 0, 714, 715, 5, 110, 0, 0, 715, 716, 5, 115, 0, 0, 716, 717, 5, 95, 0, 0, 717, 718, 5, 97, 0, 0, 718, 719, 5, 110, 0, 0, 719, 738, 5, 121, 0, 0, 720, 721, 5, 74, 0, 0, 721, 722, 5, 83, 0, 0, 722, 723, 5, 79, 0, 0, 723, 724, 5, 78, 0, 0, 724, 725, 5, 95, 0, 0, 725, 726, 5, 67, 0, 0, 726, 727, 5, 79, 0, 0, 727, 728, 5, 78, 0, 0, 728, 729, 5, 84, 0, 0, 729, 730, 5, 65, 0, 0, 730, 731, 5, 73, 0, 0, 731, 732, 5, 78, 0, 0, 732, 733, 5, 83, 0, 0, 733, 734, 5, 95, 0, 0, 734, 735, 5, 65, 0, 0, 735, 736, 5, 78, 0, 0, 736, 738, 5, 89, 0, 0, 737, 703, 1, 0, 0, 0, 737, 720, 1, 0, 0, 0, 738, 100, 1, 0, 0, 0, 739, 740, 5, 97, 0, 0, 740, 741, 5, 114, 0, 0, 741, 742, 5, 114, 0, 0, 742, 743, 5, 97, 0, 0, 743, 744, 5, 121, 0, 0, 744, 745, 5, 95, 0, 0, 745, 746, 5, 99, 0, 0, 746, 747, 5, 111, 0, 0, 747, 748, 5, 110, 0, 0, 748, 749, 5, 116, 0, 0, 749, 750, 5, 97, 0, 0, 750, 751, 5, 105, 0, 0, 751, 752, 5, 110, 0, 0, 752, 768, 5, 115, 0, 0, 753, 754, 5, 65, 0, 0, 754, 755, 5, 82, 0, 0, 755, 756, 5, 82, 0, 0, 756, 757, 5, 65, 0, 0, 757, 758, 5, 89, 0, 0, 758, 759, 5, 95, 0, 0, 759, 760, 5, 67, 0, 0, 760, 761, 5, 79, 0, 0, 761, 762, 5, 78, 0, 0, 762, 763, 5, 84, 0, 0, 763, 764, 5, 65, 0, 0, 764, 765, 5, 73, 0, 0, 765, 766, 5, 78, 0, 0, 766, 768, 5, 83, 0, 0, 767, 739, 1, 0, 0, 0, 767, 753, 1, 0, 0, 0, 768, 102, 1, 0, 0, 0, 769, 770, 5, 97, 0, 0, 770, 771, 5, 114, 0, 0, 771, 772, 5, 114, 0, 0, 772, 773, 5, 97, 0, 0, 773, 774, 5, 121, 0, 0, 774, 775, 5, 95, 0, 0, 775, 776, 5, 99, 0, 0, 776, 777, 5, 111, 0, 0, 777, 778, 5, 110, 0, 0, 778, 779, 5, 116, 0, 0, 779, 780, 5, 97, 0, 0, 780, 781, 5, 105, 0, 0, 781, 782, 5, 110, 0, 0, 782, 783, 5, 115, 0, 0, 783, 784, 5, 95, 0, 0, 784, 785, 5, 97, 0, 0, 785, 786, 5, 108, 0, 0, 786, 806, 5, 108, 0, 0, 787, 788, 5, 65, 0, 0, 788, 789, 5, 82, 0, 0, 789, 790, 5, 82, 0, 0, 790, 791, 5, 65, 0, 0, 791, 792, 5, 89, 0, 0, 792, 793, 5, 95, 0, 0, 793, 794, 5, 67, 0, 0, 794, 795, 5, 79, 0, 0, 795, 796, 5, 78, 0, 0, 796, 797, 5, 84, 0, 0, 797, 798, 5, 65, 0, 0, 798, 799, 5, 73, 0, 0, 799, 800, 5, 78, 0, 0, 800, 801, 5, 83, 0, 0, 801, 802, 5, 95, 0, 0, 802, 803, 5, 65, 0, 0, 803, 804, 5, 76, 0, 0, 804, 806, 5, 76, 0, 0, 805, 769, 1, 0, 0, 0, 805, 787, 1, 0, 0, 0, 806, 104, 1, 0, 0, 0, 807, 808, 5, 97, 0, 0, 808, 809, 5, 114, 0, 0, 809, 810, 5, 114, 0, 0, 810, 811, 5, 97, 0, 0, 811, 812, 5, 121, 0, 0, 812, 813, 5, 95, 0, 0, 813, 814, 5, 99, 0, 0, 814, 815, 5, 111, 0, 0, 815, 816, 5, 110, 0, 0, 816, 817, 5, 116, 0, 0, 817, 818, 5, 97, 0, 0, 818, 819, 5, 105, 0, 0, 819, 820, 5, 110, 0, 0, 820, 821, 5, 115, 0, 0, 821, 822, 5, 95, 0, 0, 822, 823, 5, 97, 0, 0, 823, 824, 5, 110, 0, 0, 824, 844, 5, 121, 0, 0, 825, 826, 5, 65, 0, 0, 826, 827, 5, 82, 0, 0, 827, 828, 5, 82, 0, 0, 828, 829, 5, 65, 0, 0, 829, 830, 5, 89, 0, 0, 830, 831, 5, 95, 0, 0, 831, 832, 5, 67, 0, 0, 832, 833, 5, 79, 0, 0, 833, 834, 5, 78, 0, 0, 834, 835, 5, 84, 0, 0, 835, 836, 5, 65, 0, 0, 836, 837, 5, 73, 0, 0, 837, 838, 5, 78, 0, 0, 838, 839, 5, 83, 0, 0, 839, 840, 5, 95, 0, 0, 840, 841, 5, 65, 0, 0, 841, 842, 5, 78, 0, 0, 842, 844, 5, 89, 0, 0, 843, 807, 1, 0, 0, 0, 843, 825, 1, 0, 0, 0, 844, 106, 1, 0, 0, 0, 845, 846, 5, 97, 0, 0, 846, 847, 5, 114, 0, 0, 847, 848, 5, 114, 0, 0, 848, 849, 5, 97, 0, 0, 849, 850, 5, 121, 0, 0, 850, 851, 5, 95, 0, 0, 851, 852, 5, 108, 0, 0, 852, 853, 5, 101, 0, 0, 853, 854, 5, 110, 0, 0, 854, 855, 5, 103, 0, 0, 855, 856, 5, 116, 0, 0, 856, 870, 5, 104, 0, 0, 857, 858, 5, 65, 0, 0, 858, 859, 5, 82, 0, 0, 859, 860, 5, 82, 0, 0, 860, 861, 5, 65, 0, 0, 861, 862, 5, 89, 0, 0, 862, 863, 5, 95, 0, 0, 863, 864, 5, 76, 0, 0, 864, 865, 5, 69, 0, 0, 865, 866, 5, 78, 0, 0, 866, 867, 5, 71, 0, 0, 867, 868, 5, 84, 0, 0, 868, 870, 5, 72, 0, 0, 869, 845, 1, 0, 0, 0, 869, 857, 1, 0, 0, 0, 870, 108, 1, 0, 0, 0, 871, 872, 5, 101, 0, 0, 872, 873, 5, 108, 0, 0, 873, 874, 5, 101, 0, 0, 874, 875, 5, 109, 0, 0, 875, 876, 5, 101, 0, 0, 876, 877, 5, 110, 0, 0, 877, 878, 5, 116, 0, 0, 878, 879, 5, 95, 0, 0, 879, 880, 5, 102, 0, 0, 880, 881, 5, 105, 0, 0, 881, 882, 5, 108, 0, 0, 882, 883, 5, 116, 0, 0, 883, 884, 5, 101, 0, 0, 884, 900, 5, 114, 0, 0, 885, 886, 5, 69, 0, 0, 886, 887, 5, 76, 0, 0, 887, 888, 5, 69, 0, 0, 888, 889, 5, 77, 0, 0, 889, 890, 5, 69, 0, 0, 890, 891, 5, 78, 0, 0, 891, 892, 5, 84, 0, 0, 892, 893, 5, 95, 0, 0, 893, 894, 5, 70, 0, 0, 894, 895, 5, 73, 0, 0, 895, 896, 5, 76, 0, 0, 896, 897, 5, 84, 0, 0, 897, 898, 5, 69, 0, 0, 898, 900, 5, 82, 0, 0, 899, 871, 1, 0, 0, 0, 899, 885, 1, 0, 0, 0, 900, 110, 1, 0, 0, 0, 901, 902, 5, 115, 0, 0, 902, 903, 5, 116, 0, 0, 903, 904, 5, 95, 0, 0, 904, 905, 5, 101, 0, 0, 905, 906, 5, 113, 0, 0, 906, 907, 5, 117, 0, 0, 907, 908, 5, 97, 0, 0, 908, 909, 5, 108, 0, 0, 909, 920, 5, 115, 0, 0, 910, 911, 5, 83, 0, 0, 911, 912, 5, 84, 0, 0, 912, 913, 5, 95, 0, 0, 913, 914, 5, 69, 0, 0, 914, 915, 5, 81, 0, 0, 915, 916, 5, 85, 0, 0, 916, 917, 5, 65, 0, 0, 917, 918, 5, 76, 0, 0, 918, 920, 5, 83, 0, 0, 919, 901, 1, 0, 0, 0, 919, 910, 1, 0, 0, 0, 920, 112, 1, 0, 0, 0, 921, 922, 5, 115, 0, 0, 922, 923, 5, 116, 0, 0, 923, 924, 5, 95, 0, 0, 924, 925, 5, 116, 0, 0, 925, 926, 5, 111, 0, 0, 926, 927, 5, 117, 0, 0, 927, 928, 5, 99, 0, 0, 928, 929, 5, 104, 0, 0, 929, 930, 5, 101, 0, 0, 930, 942, 5, 115, 0, 0, 931, 932, 5, 83, 0, 0, 932, 933, 5, 84, 0, 0, 933, 934, 5, 95, 0, 0, 934, 935, 5, 84, 0, 0, 935, 936, 5, 79, 0, 0, 936, 937, 5, 85, 0, 0, 937, 938, 5, 67, 0, 0, 938, 939, 5, 72, 0, 0, 939, 940, 5, 69, 0, 0, 940, 942, 5, 83, 0, 0, 941, 921, 1, 0, 0, 0, 941, 931, 1, 0, 0, 0, 942, 114, 1, 0, 0, 0, 943, 944, 5, 115, 0, 0, 944, 945, 5, 116, 0, 0, 945, 946, 5, 95, 0, 0, 946, 947, 5, 111, 0, 0, 947, 948, 5, 118, 0, 0, 948, 949, 5, 101, 0, 0, 949, 950, 5, 114, 0, 0, 950, 951, 5, 108, 0, 0, 951, 952, 5, 97, 0, 0, 952, 953, 5, 112, 0, 0, 953, 966, 5, 115, 0, 0, 954, 955, 5, 83, 0, 0, 955, 956, 5, 84, 0, 0, 956, 957, 5, 95, 0, 0, 957, 958, 5, 79, 0, 0, 958, 959, 5, 86, 0, 0, 959, 960, 5, 69, 0, 0, 960, 961, 5, 82, 0, 0, 961, 962, 5, 76, 0, 0, 962, 963, 5, 65, 0, 0, 963, 964, 5, 80, 0, 0, 964, 966, 5, 83, 0, 0, 965, 943, 1, 0, 0, 0, 965, 954, 1, 0, 0, 0, 966, 116, 1, 0, 0, 0, 967, 968, 5, 115, 0, 0, 968, 969, 5, 116, 0, 0, 969, 970, 5, 95, 0, 0, 970, 971, 5, 99, 0, 0, 971, 972, 5, 114, 0, 0, 972, 973, 5, 111, 0, 0, 973, 974, 5, 115, 0, 0, 974, 975, 5, 115, 0, 0, 975, 976, 5, 101, 0, 0, 976, 988, 5, 115, 0, 0, 977, 978, 5, 83, 0, 0, 978, 979, 5, 84, 0, 0, 979, 980, 5, 95, 0, 0, 980, 981, 5, 67, 0, 0, 981, 982, 5, 82, 0, 0, 982, 983, 5, 79, 0, 0, 983, 984, 5, 83, 0, 0, 984, 985, 5, 83, 0, 0, 985, 986, 5, 69, 0, 0, 986, 988, 5, 83, 0, 0, 987, 967, 1, 0, 0, 0, 987, 977, 1, 0, 0, 0, 988, 118, 1, 0, 0, 0, 989, 990, 5, 115, 0, 0, 990, 991, 5, 116, 0, 0, 991, 992, 5, 95, 0, 0, 992, 993, 5, 99, 0, 0, 993, 994, 5, 111, 0, 0, 994, 995, 5, 110, 0, 0, 995, 996, 5, 116, 0, 0, 996, 997, 5, 97, 0, 0, 997, 998, 5, 105, 0, 0, 998, 999, 5, 110, 0, 0, 999, 1012, 5, 115, 0, 0, 1000, 1001, 5, 83, 0, 0, 1001, 1002, 5, 84, 0, 0, 1002, 1003, 5, 95, 0, 0, 1003, 1004, 5, 67, 0, 0, 1004, 1005, 5, 79, 0, 0, 1005, 1006, 5, 78, 0, 0, 1006, 1007, 5, 84, 0, 0, 1007, 1008, 5, 65, 0, 0, 1008, 1009, 5, 73, 0, 0, 1009, 1010, 5, 78, 0, 0, 1010, 1012, 5, 83, 0, 0, 1011, 989, 1, 0, 0, 0, 1011, 1000, 1, 0, 0, 0, 1012, 120, 1, 0, 0, 0, 1013, 1014, 5, 115, 0, 0, 1014, 1015, 5, 116, 0, 0, 1015, 1016, 5, 95, 0, 0, 1016, 1017, 5, 105, 0, 0, 1017, 1018, 5, 110, 0, 0, 1018, 1019, 5, 116, 0, 0, 1019, 1020, 5, 101, 0, 0, 1020, 1021, 5, 114, 0, 0, 1021, 1022, 5, 115, 0, 0, 1022, 1023, 5, 101, 0, 0, 1023, 1024, 5, 99, 0, 0, 1024, 1025, 5, 116, 0, 0, 1025, 1040, 5, 115, 0, 0, 1026, 1027, 5, 83, 0, 0, 1027, 1028, 5, 84, 0, 0, 1028, 1029, 5, 95, 0, 0, 1029, 1030, 5, 73, 0, 0, 1030, 1031, 5, 78, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 69, 0, 0, 1033, 1034, 5, 82, 0, 0, 1034, 1035, 5, 83, 0, 0, 1035, 1036, 5, 69, 0, 0, 1036, 1037, 5, 67, 0, 0, 1037, 1038, 5, 84, 0, 0, 1038, 1040, 5, 83, 0, 0, 1039, 1013, 1, 0, 0, 0, 1039, 1026, 1, 0, 0, 0, 1040, 122, 1, 0, 0, 0, 1041, 1042, 5, 115, 0, 0, 1042, 1043, 5, 116, 0, 0, 1043, 1044, 5, 95, 0, 0, 1044, 1045, 5, 119, 0, 0, 1045, 1046, 5, 105, 0, 0, 1046, 1047, 5, 116, 0, 0, 1047, 1048, 5, 104, 0, 0, 1048, 1049, 5, 105, 0, 0, 1049, 1060, 5, 110, 0, 0, 1050, 1051, 5, 83, 0, 0, 1051, 1052, 5, 84, 0, 0, 1052, 1053, 5, 95, 0, 0, 1053, 1054, 5, 87, 0, 0, 1054, 1055, 5, 73, 0, 0, 1055, 1056, 5, 84, 0, 0, 1056, 1057, 5, 72, 0, 0, 1057, 1058, 5, 73, 0, 0, 1058, 1060, 5, 78, 0, 0, 1059, 1041, 1, 0, 0, 0, 1059, 1050, 1, 0, 0, 0, 1060, 124, 1, 0, 0, 0, 1061, 1062, 5, 115, 0, 0, 1062, 1063, 5, 116, 0, 0, 1063, 1064, 5, 95, 0, 0, 1064, 1065, 5, 100, 0, 0, 1065, 1066, 5, 119, 0, 0, 1066, 1067, 5, 105, 0, 0, 1067, 1068, 5, 116, 0, 0, 1068, 1069, 5, 104, 0, 0, 1069, 1070, 5, 105, 0, 0, 1070, 1082, 5, 110, 0, 0, 1071, 1072, 5, 83, 0, 0, 1072, 1073, 5, 84, 0, 0, 1073, 1074, 5, 95, 0, 0, 1074, 1075, 5, 68, 0, 0, 1075, 1076, 5, 87, 0, 0, 1076, 1077, 5, 73, 0, 0, 1077, 1078, 5, 84, 0, 0, 1078, 1079, 5, 72, 0, 0, 1079, 1080, 5, 73, 0, 0, 1080, 1082, 5, 78, 0, 0, 1081, 1061, 1, 0, 0, 0, 1081, 1071, 1, 0, 0, 0, 1082, 126, 1, 0, 0, 0, 1083, 1084, 5, 115, 0, 0, 1084, 1085, 5, 116, 0, 0, 1085, 1086, 5, 95, 0, 0, 1086, 1087, 5, 105, 0, 0, 1087, 1088, 5, 115, 0, 0, 1088, 1089, 5, 118, 0, 0, 1089, 1090, 5, 97, 0, 0, 1090, 1091, 5, 108, 0, 0, 1091, 1092, 5, 105, 0, 0, 1092, 1104, 5, 100, 0, 0, 1093, 1094, 5, 83, 0, 0, 1094, 1095, 5, 84, 0, 0, 1095, 1096, 5, 95, 0, 0, 1096, 1097, 5, 73, 0, 0, 1097, 1098, 5, 83, 0, 0, 1098, 1099, 5, 86, 0, 0, 1099, 1100, 5, 65, 0, 0, 1100, 1101, 5, 76, 0, 0, 1101, 1102, 5, 73, 0, 0, 1102, 1104, 5, 68, 0, 0, 1103, 1083, 1, 0, 0, 0, 1103, 1093, 1, 0, 0, 0, 1104, 128, 1, 0, 0, 0, 1105, 1106, 5, 116, 0, 0, 1106, 1107, 5, 114, 0, 0, 1107, 1108, 5, 117, 0, 0, 1108, 1133, 5, 101, 0, 0, 1109, 1110, 5, 84, 0, 0, 1110, 1111, 5, 114, 0, 0, 1111, 1112, 5, 117, 0, 0, 1112, 1133, 5, 101, 0, 0, 1113, 1114, 5, 84, 0, 0, 1114, 1115, 5, 82, 0, 0, 1115, 1116, 5, 85, 0, 0, 1116, 1133, 5, 69, 0, 0, 1117, 1118, 5, 102, 0, 0, 1118, 1119, 5, 97, 0, 0, 1119, 1120, 5, 108, 0, 0, 1120, 1121, 5, 115, 0, 0, 1121, 1133, 5, 101, 0, 0, 1122, 1123, 5, 70, 0, 0, 1123, 1124, 5, 97, 0, 0, 1124, 1125, 5, 108, 0, 0, 1125, 1126, 5, 115, 0, 0, 1126, 1133, 5, 101, 0, 0, 1127, 1128, 5, 70, 0, 0, 1128, 1129, 5, 65, 0, 0, 1129, 1130, 5, 76, 0, 0, 1130, 1131, 5, 83, 0, 0, 1131, 1133, 5, 69, 0, 0, 1132, 1105, 1, 0, 0, 0, 1132, 1109, 1, 0, 0, 0, 1132, 1113, 1, 0, 0, 0, 1132, 1117, 1, 0, 0, 0, 1132, 1122, 1, 0, 0, 0, 1132, 1127, 1, 0, 0, 0, 1133, 130, 1, 0, 0, 0, 1134, 1139, 3, 161, 80, 0, 1135, 1139, 3, 163, 81, 0, 1136, 1139, 3, 165, 82, 0, 1137, 1139, 3, 159, 79, 0, 1138, 1134, 1, 0, 0, 0, 1138, 1135, 1, 0, 0, 0, 1138, 1136, 1, 0, 0, 0, 1138, 1137, 1, 0, 0, 0, 1139, 132, 1, 0, 0, 0, 1140, 1143, 3, 177, 88, 0, 1141, 1143, 3, 179, 89, 0, 1142, 1140, 1, 0, 0, 0, 1142, 1141, 1, 0, 0, 0, 1143, 134, 1, 0, 0, 0, 1144, 1149, 3, 155, 77, 0, 1145, 1148, 3, 155, 77, 0, 1146, 1148, 3, 157, 78, 0, 1147, 1145, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 1151, 1, 0, 0, 0, 1149, 1147, 1, 0, 0, 0, 1149, 1150, 1, 0, 0, 0, 1150, 136, 1, 0, 0, 0, 1151, 1149, 1, 0, 0, 0, 1152, 1153, 5, 36, 0, 0, 1153, 1154, 5, 109, 0, 0, 1154, 1155, 5, 101, 0, 0, 1155, 1156, 5, 116, 0, 0, 1156, 1157, 5, 97, 0, 0, 1157, 138, 1, 0, 0, 0, 1158, 1160, 3, 145, 72, 0, 1159, 1158, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1171, 1, 0, 0, 0, 1161, 1163, 5, 34, 0, 0, 1162, 1164, 3, 147, 73, 0, 1163, 1162, 1, 0, 0, 0, 1163, 1164, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1172, 5, 34, 0, 0, 1166, 1168, 5, 39, 0, 0, 1167, 1169, 3, 149, 74, 0, 1168, 1167, 1, 0, 0, 0, 1168, 1169, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1172, 5, 39, 0, 0, 1171, 1161, 1, 0, 0, 0, 1171, 1166, 1, 0, 0, 0, 1172, 140, 1, 0, 0, 0, 1173, 1176, 3, 135, 67, 0, 1174, 1176, 3, 137, 68, 0, 1175, 1173, 1, 0, 0, 0, 1175, 1174, 1, 0, 0, 0, 1176, 1184, 1, 0, 0, 0, 1177, 1180, 5, 91, 0, 0, 1178, 1181, 3, 139, 69, 0, 1179, 1181, 3, 161, 80, 0, 1180, 1178, 1, 0, 0, 0, 1180, 1179, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1183, 5, 93, 0, 0, 1183, 1185, 1, 0, 0, 0, 1184, 1177, 1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, 1184, 1, 0, 0, 0, 1186, 1187, 1, 0, 0, 0, 1187, 142, 1, 0, 0, 0, 1188, 1189, 5, 36, 0, 0, 1189, 1190, 5, 91, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1192, 3, 135, 67, 0, 1192, 1193, 5, 93, 0, 0, 1193, 144, 1, 0, 0, 0, 1194, 1195, 5, 117, 0, 0, 1195, 1198, 5, 56, 0, 0, 1196, 1198, 7, 0, 0, 0, 1197, 1194, 1, 0, 0, 0, 1197, 1196, 1, 0, 0, 0, 1198, 146, 1, 0, 0, 0, 1199, 1201, 3, 151, 75, 0, 1200, 1199, 1, 0, 0, 0, 1201, 1202, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 148, 1, 0, 0, 0, 1204, 1206, 3, 153, 76, 0, 1205, 1204, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 150, 1, 0, 0, 0, 1209, 1217, 8, 1, 0, 0, 1210, 1217, 3, 193, 96, 0, 1211, 1212, 5, 92, 0, 0, 1212, 1217, 5, 10, 0, 0, 1213, 1214, 5, 92, 0, 0, 1214, 1215, 5, 13, 0, 0, 1215, 1217, 5, 10, 0, 0, 1216, 1209, 1, 0, 0, 0, 1216, 1210, 1, 0, 0, 0, 1216, 1211, 1, 0, 0, 0, 1216, 1213, 1, 0, 0, 0, 1217, 152, 1, 0, 0, 0, 1218, 1226, 8, 2, 0, 0, 1219, 1226, 3, 193, 96, 0, 1220, 1221, 5, 92, 0, 0, 1221, 1226, 5, 10, 0, 0, 1222, 1223, 5, 92, 0, 0, 1223, 1224, 5, 13, 0, 0, 1224, 1226, 5, 10, 0, 0, 1225, 1218, 1, 0, 0, 0, 1225, 1219, 1, 0, 0, 0, 1225, 1220, 1, 0, 0, 0, 1225, 1222, 1, 0, 0, 0, 1226, 154, 1, 0, 0, 0, 1227, 1228, 7, 3, 0, 0, 1228, 156, 1, 0, 0, 0, 1229, 1230, 7, 4, 0, 0, 1230, 158, 1, 0, 0, 0, 1231, 1232, 5, 48, 0, 0, 1232, 1234, 7, 5, 0, 0, 1233, 1235, 7, 6, 0, 0, 1234, 1233, 1, 0, 0, 0, 1235, 1236, 1, 0, 0, 0, 1236, 1234, 1, 0, 0, 0, 1236, 1237, 1, 0, 0, 0, 1237, 160, 1, 0, 0, 0, 1238, 1242, 3, 167, 83, 0, 1239, 1241, 3, 157, 78, 0, 1240, 1239, 1, 0, 0, 0, 1241, 1244, 1, 0, 0, 0, 1242, 1240, 1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, 1243, 1247, 1, 0, 0, 0, 1244, 1242, 1, 0, 0, 0, 1245, 1247, 5, 48, 0, 0, 1246, 1238, 1, 0, 0, 0, 1246, 1245, 1, 0, 0, 0, 1247, 162, 1, 0, 0, 0, 1248, 1252, 5, 48, 0, 0, 1249, 1251, 3, 169, 84, 0, 1250, 1249, 1, 0, 0, 0, 1251, 1254, 1, 0, 0, 0, 1252, 1250, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 164, 1, 0, 0, 0, 1254, 1252, 1, 0, 0, 0, 1255, 1256, 5, 48, 0, 0, 1256, 1257, 7, 7, 0, 0, 1257, 1258, 3, 189, 94, 0, 1258, 166, 1, 0, 0, 0, 1259, 1260, 7, 8, 0, 0, 1260, 168, 1, 0, 0, 0, 1261, 1262, 7, 9, 0, 0, 1262, 170, 1, 0, 0, 0, 1263, 1264, 7, 10, 0, 0, 1264, 172, 1, 0, 0, 0, 1265, 1266, 3, 171, 85, 0, 1266, 1267, 3, 171, 85, 0, 1267, 1268, 3, 171, 85, 0, 1268, 1269, 3, 171, 85, 0, 1269, 174, 1, 0, 0, 0, 1270, 1271, 5, 92, 0, 0, 1271, 1272, 5, 117, 0, 0, 1272, 1273, 1, 0, 0, 0, 1273, 1281, 3, 173, 86, 0, 1274, 1275, 5, 92, 0, 0, 1275, 1276, 5, 85, 0, 0, 1276, 1277, 1, 0, 0, 0, 1277, 1278, 3, 173, 86, 0, 1278, 1279, 3, 173, 86, 0, 1279, 1281, 1, 0, 0, 0, 1280, 1270, 1, 0, 0, 0, 1280, 1274, 1, 0, 0, 0, 1281, 176, 1, 0, 0, 0, 1282, 1284, 3, 181, 90, 0, 1283, 1285, 3, 183, 91, 0, 1284, 1283, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1290, 1, 0, 0, 0, 1286, 1287, 3, 185, 92, 0, 1287, 1288, 3, 183, 91, 0, 1288, 1290, 1, 0, 0, 0, 1289, 1282, 1, 0, 0, 0, 1289, 1286, 1, 0, 0, 0, 1290, 178, 1, 0, 0, 0, 1291, 1292, 5, 48, 0, 0, 1292, 1295, 7, 7, 0, 0, 1293, 1296, 3, 187, 93, 0, 1294, 1296, 3, 189, 94, 0, 1295, 1293, 1, 0, 0, 0, 1295, 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1298, 3, 191, 95, 0, 1298, 180, 1, 0, 0, 0, 1299, 1301, 3, 185, 92, 0, 1300, 1299, 1, 0, 0, 0, 1300, 1301, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, 1303, 5, 46, 0, 0, 1303, 1308, 3, 185, 92, 0, 1304, 1305, 3, 185, 92, 0, 1305, 1306, 5, 46, 0, 0, 1306, 1308, 1, 0, 0, 0, 1307, 1300, 1, 0, 0, 0, 1307, 1304, 1, 0, 0, 0, 1308, 182, 1, 0, 0, 0, 1309, 1311, 7, 11, 0, 0, 1310, 1312, 7, 12, 0, 0, 1311, 1310, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, 3, 185, 92, 0, 1314, 184, 1, 0, 0, 0, 1315, 1317, 3, 157, 78, 0, 1316, 1315, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 1316, 1, 0, 0, 0, 1318, 1319, 1, 0, 0, 0, 1319, 186, 1, 0, 0, 0, 1320, 1322, 3, 189, 94, 0, 1321, 1320, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 1324, 5, 46, 0, 0, 1324, 1329, 3, 189, 94, 0, 1325, 1326, 3, 189, 94, 0, 1326, 1327, 5, 46, 0, 0, 1327, 1329, 1, 0, 0, 0, 1328, 1321, 1, 0, 0, 0, 1328, 1325, 1, 0, 0, 0, 1329, 188, 1, 0, 0, 0, 1330, 1332, 3, 171, 85, 0, 1331, 1330, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1331, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 190, 1, 0, 0, 0, 1335, 1337, 7, 13, 0, 0, 1336, 1338, 7, 12, 0, 0, 1337, 1336, 1, 0, 0, 0, 1337, 1338, 1, 0, 0, 0, 1338, 1339, 1, 0, 0, 0, 1339, 1340, 3, 185, 92, 0, 1340, 192, 1, 0, 0, 0, 1341, 1342, 5, 92, 0, 0, 1342, 1357, 7, 14, 0, 0, 1343, 1344, 5, 92, 0, 0, 1344, 1346, 3, 169, 84, 0, 1345, 1347, 3, 169, 84, 0, 1346, 1345, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1349, 1, 0, 0, 0, 1348, 1350, 3, 169, 84, 0, 1349, 1348, 1, 0, 0, 0, 1349, 1350, 1, 0, 0, 0, 1350, 1357, 1, 0, 0, 0, 1351, 1352, 5, 92, 0, 0, 1352, 1353, 5, 120, 0, 0, 1353, 1354, 1, 0, 0, 0, 1354, 1357, 3, 189, 94, 0, 1355, 1357, 3, 175, 87, 0, 1356, 1341, 1, 0, 0, 0, 1356, 1343, 1, 0, 0, 0, 1356, 1351, 1, 0, 0, 0, 1356, 1355, 1, 0, 0, 0, 1357, 194, 1, 0, 0, 0, 1358, 1360, 7, 15, 0, 0, 1359, 1358, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 1359, 1, 0, 0, 0, 1361, 1362, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1364, 6, 97, 0, 0, 1364, 196, 1, 0, 0, 0, 1365, 1367, 5, 13, 0, 0, 1366, 1368, 5, 10, 0, 0, 1367, 1366, 1, 0, 0, 0, 1367, 1368, 1, 0, 0, 0, 1368, 1371, 1, 0, 0, 0, 1369, 1371, 5, 10, 0, 0, 1370, 1365, 1, 0, 0, 0, 1370, 1369, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1373, 6, 98, 0, 0, 1373, 198, 1, 0, 0, 0, 79, 0, 237, 251, 273, 299, 327, 347, 367, 391, 413, 437, 455, 463, 505, 525, 562, 570, 586, 610, 621, 627, 632, 634, 665, 701, 737, 767, 805, 843, 869, 899, 919, 941, 965, 987, 1011, 1039, 1059, 1081, 1103, 1132, 1138, 1142, 1147, 1149, 1159, 1163, 1168, 1171, 1175, 1180, 1186, 1197, 1202, 1207, 1216, 1225, 1236, 1242, 1246, 1252, 1280, 1284, 1289, 1295, 1300, 1307, 1311, 1318, 1321, 1328, 1333, 1337, 1346, 1349, 1356, 1361, 1367, 1370, 1, 6, 0, 0] \ No newline at end of file diff --git a/internal/parser/planparserv2/generated/PlanLexer.tokens b/internal/parser/planparserv2/generated/PlanLexer.tokens index 374477f781..4e6be20d92 100644 --- a/internal/parser/planparserv2/generated/PlanLexer.tokens +++ b/internal/parser/planparserv2/generated/PlanLexer.tokens @@ -16,56 +16,62 @@ EXISTS=15 TEXTMATCH=16 PHRASEMATCH=17 RANDOMSAMPLE=18 -INTERVAL=19 -ISO=20 -MINIMUM_SHOULD_MATCH=21 -ASSIGN=22 -ADD=23 -SUB=24 -MUL=25 -DIV=26 -MOD=27 -POW=28 -SHL=29 -SHR=30 -BAND=31 -BOR=32 -BXOR=33 -AND=34 -OR=35 -ISNULL=36 -ISNOTNULL=37 -BNOT=38 -NOT=39 -IN=40 -EmptyArray=41 -JSONContains=42 -JSONContainsAll=43 -JSONContainsAny=44 -ArrayContains=45 -ArrayContainsAll=46 -ArrayContainsAny=47 -ArrayLength=48 -ElementFilter=49 -STEuqals=50 -STTouches=51 -STOverlaps=52 -STCrosses=53 -STContains=54 -STIntersects=55 -STWithin=56 -STDWithin=57 -STIsValid=58 -BooleanConstant=59 -IntegerConstant=60 -FloatingConstant=61 -Identifier=62 -Meta=63 -StringLiteral=64 -JSONIdentifier=65 -StructSubFieldIdentifier=66 -Whitespace=67 -Newline=68 +MATCH_ALL=19 +MATCH_ANY=20 +MATCH_LEAST=21 +MATCH_MOST=22 +MATCH_EXACT=23 +INTERVAL=24 +ISO=25 +MINIMUM_SHOULD_MATCH=26 +THRESHOLD=27 +ASSIGN=28 +ADD=29 +SUB=30 +MUL=31 +DIV=32 +MOD=33 +POW=34 +SHL=35 +SHR=36 +BAND=37 +BOR=38 +BXOR=39 +AND=40 +OR=41 +ISNULL=42 +ISNOTNULL=43 +BNOT=44 +NOT=45 +IN=46 +EmptyArray=47 +JSONContains=48 +JSONContainsAll=49 +JSONContainsAny=50 +ArrayContains=51 +ArrayContainsAll=52 +ArrayContainsAny=53 +ArrayLength=54 +ElementFilter=55 +STEuqals=56 +STTouches=57 +STOverlaps=58 +STCrosses=59 +STContains=60 +STIntersects=61 +STWithin=62 +STDWithin=63 +STIsValid=64 +BooleanConstant=65 +IntegerConstant=66 +FloatingConstant=67 +Identifier=68 +Meta=69 +StringLiteral=70 +JSONIdentifier=71 +StructSubFieldIdentifier=72 +Whitespace=73 +Newline=74 '('=1 ')'=2 '['=3 @@ -79,17 +85,17 @@ Newline=68 '>='=11 '=='=12 '!='=13 -'='=22 -'+'=23 -'-'=24 -'*'=25 -'/'=26 -'%'=27 -'**'=28 -'<<'=29 -'>>'=30 -'&'=31 -'|'=32 -'^'=33 -'~'=38 -'$meta'=63 +'='=28 +'+'=29 +'-'=30 +'*'=31 +'/'=32 +'%'=33 +'**'=34 +'<<'=35 +'>>'=36 +'&'=37 +'|'=38 +'^'=39 +'~'=44 +'$meta'=69 diff --git a/internal/parser/planparserv2/generated/plan_base_visitor.go b/internal/parser/planparserv2/generated/plan_base_visitor.go index eb1708aece..0f8255b369 100644 --- a/internal/parser/planparserv2/generated/plan_base_visitor.go +++ b/internal/parser/planparserv2/generated/plan_base_visitor.go @@ -11,6 +11,10 @@ func (v *BasePlanVisitor) VisitString(ctx *StringContext) interface{} { return v.VisitChildren(ctx) } +func (v *BasePlanVisitor) VisitMatchAny(ctx *MatchAnyContext) interface{} { + return v.VisitChildren(ctx) +} + func (v *BasePlanVisitor) VisitFloating(ctx *FloatingContext) interface{} { return v.VisitChildren(ctx) } @@ -59,6 +63,10 @@ func (v *BasePlanVisitor) VisitPhraseMatch(ctx *PhraseMatchContext) interface{} return v.VisitChildren(ctx) } +func (v *BasePlanVisitor) VisitMatchLeast(ctx *MatchLeastContext) interface{} { + return v.VisitChildren(ctx) +} + func (v *BasePlanVisitor) VisitArrayLength(ctx *ArrayLengthContext) interface{} { return v.VisitChildren(ctx) } @@ -83,6 +91,10 @@ func (v *BasePlanVisitor) VisitRange(ctx *RangeContext) interface{} { return v.VisitChildren(ctx) } +func (v *BasePlanVisitor) VisitMatchAll(ctx *MatchAllContext) interface{} { + return v.VisitChildren(ctx) +} + func (v *BasePlanVisitor) VisitSTIsValid(ctx *STIsValidContext) interface{} { return v.VisitChildren(ctx) } @@ -103,6 +115,10 @@ func (v *BasePlanVisitor) VisitSTOverlaps(ctx *STOverlapsContext) interface{} { return v.VisitChildren(ctx) } +func (v *BasePlanVisitor) VisitMatchMost(ctx *MatchMostContext) interface{} { + return v.VisitChildren(ctx) +} + func (v *BasePlanVisitor) VisitJSONIdentifier(ctx *JSONIdentifierContext) interface{} { return v.VisitChildren(ctx) } @@ -115,6 +131,10 @@ func (v *BasePlanVisitor) VisitParens(ctx *ParensContext) interface{} { return v.VisitChildren(ctx) } +func (v *BasePlanVisitor) VisitMatchExact(ctx *MatchExactContext) interface{} { + return v.VisitChildren(ctx) +} + func (v *BasePlanVisitor) VisitJSONContainsAll(ctx *JSONContainsAllContext) interface{} { return v.VisitChildren(ctx) } diff --git a/internal/parser/planparserv2/generated/plan_lexer.go b/internal/parser/planparserv2/generated/plan_lexer.go index ab794760f6..0f72542f9e 100644 --- a/internal/parser/planparserv2/generated/plan_lexer.go +++ b/internal/parser/planparserv2/generated/plan_lexer.go @@ -44,46 +44,50 @@ func planlexerLexerInit() { } staticData.LiteralNames = []string{ "", "'('", "')'", "'['", "','", "']'", "'{'", "'}'", "'<'", "'<='", - "'>'", "'>='", "'=='", "'!='", "", "", "", "", "", "", "", "", "'='", - "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'", "'&'", "'|'", - "'^'", "", "", "", "", "'~'", "", "", "", "", "", "", "", "", "", "", - "", "", "", "", "", "", "", "", "", "", "", "", "", "", "'$meta'", + "'>'", "'>='", "'=='", "'!='", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "'='", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", + "'>>'", "'&'", "'|'", "'^'", "", "", "", "", "'~'", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "'$meta'", } staticData.SymbolicNames = []string{ "", "", "", "", "", "", "LBRACE", "RBRACE", "LT", "LE", "GT", "GE", "EQ", "NE", "LIKE", "EXISTS", "TEXTMATCH", "PHRASEMATCH", "RANDOMSAMPLE", - "INTERVAL", "ISO", "MINIMUM_SHOULD_MATCH", "ASSIGN", "ADD", "SUB", "MUL", - "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR", "BXOR", "AND", "OR", - "ISNULL", "ISNOTNULL", "BNOT", "NOT", "IN", "EmptyArray", "JSONContains", - "JSONContainsAll", "JSONContainsAny", "ArrayContains", "ArrayContainsAll", - "ArrayContainsAny", "ArrayLength", "ElementFilter", "STEuqals", "STTouches", - "STOverlaps", "STCrosses", "STContains", "STIntersects", "STWithin", - "STDWithin", "STIsValid", "BooleanConstant", "IntegerConstant", "FloatingConstant", - "Identifier", "Meta", "StringLiteral", "JSONIdentifier", "StructSubFieldIdentifier", - "Whitespace", "Newline", - } - staticData.RuleNames = []string{ - "T__0", "T__1", "T__2", "T__3", "T__4", "LBRACE", "RBRACE", "LT", "LE", - "GT", "GE", "EQ", "NE", "LIKE", "EXISTS", "TEXTMATCH", "PHRASEMATCH", - "RANDOMSAMPLE", "INTERVAL", "ISO", "MINIMUM_SHOULD_MATCH", "ASSIGN", - "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR", - "BXOR", "AND", "OR", "ISNULL", "ISNOTNULL", "BNOT", "NOT", "IN", "EmptyArray", + "MATCH_ALL", "MATCH_ANY", "MATCH_LEAST", "MATCH_MOST", "MATCH_EXACT", + "INTERVAL", "ISO", "MINIMUM_SHOULD_MATCH", "THRESHOLD", "ASSIGN", "ADD", + "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR", "BXOR", + "AND", "OR", "ISNULL", "ISNOTNULL", "BNOT", "NOT", "IN", "EmptyArray", "JSONContains", "JSONContainsAll", "JSONContainsAny", "ArrayContains", "ArrayContainsAll", "ArrayContainsAny", "ArrayLength", "ElementFilter", "STEuqals", "STTouches", "STOverlaps", "STCrosses", "STContains", "STIntersects", "STWithin", "STDWithin", "STIsValid", "BooleanConstant", "IntegerConstant", "FloatingConstant", "Identifier", "Meta", "StringLiteral", "JSONIdentifier", - "StructSubFieldIdentifier", "EncodingPrefix", "DoubleSCharSequence", - "SingleSCharSequence", "DoubleSChar", "SingleSChar", "Nondigit", "Digit", - "BinaryConstant", "DecimalConstant", "OctalConstant", "HexadecimalConstant", - "NonzeroDigit", "OctalDigit", "HexadecimalDigit", "HexQuad", "UniversalCharacterName", - "DecimalFloatingConstant", "HexadecimalFloatingConstant", "FractionalConstant", - "ExponentPart", "DigitSequence", "HexadecimalFractionalConstant", "HexadecimalDigitSequence", + "StructSubFieldIdentifier", "Whitespace", "Newline", + } + staticData.RuleNames = []string{ + "T__0", "T__1", "T__2", "T__3", "T__4", "LBRACE", "RBRACE", "LT", "LE", + "GT", "GE", "EQ", "NE", "LIKE", "EXISTS", "TEXTMATCH", "PHRASEMATCH", + "RANDOMSAMPLE", "MATCH_ALL", "MATCH_ANY", "MATCH_LEAST", "MATCH_MOST", + "MATCH_EXACT", "INTERVAL", "ISO", "MINIMUM_SHOULD_MATCH", "THRESHOLD", + "ASSIGN", "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", + "BOR", "BXOR", "AND", "OR", "ISNULL", "ISNOTNULL", "BNOT", "NOT", "IN", + "EmptyArray", "JSONContains", "JSONContainsAll", "JSONContainsAny", + "ArrayContains", "ArrayContainsAll", "ArrayContainsAny", "ArrayLength", + "ElementFilter", "STEuqals", "STTouches", "STOverlaps", "STCrosses", + "STContains", "STIntersects", "STWithin", "STDWithin", "STIsValid", + "BooleanConstant", "IntegerConstant", "FloatingConstant", "Identifier", + "Meta", "StringLiteral", "JSONIdentifier", "StructSubFieldIdentifier", + "EncodingPrefix", "DoubleSCharSequence", "SingleSCharSequence", "DoubleSChar", + "SingleSChar", "Nondigit", "Digit", "BinaryConstant", "DecimalConstant", + "OctalConstant", "HexadecimalConstant", "NonzeroDigit", "OctalDigit", + "HexadecimalDigit", "HexQuad", "UniversalCharacterName", "DecimalFloatingConstant", + "HexadecimalFloatingConstant", "FractionalConstant", "ExponentPart", + "DigitSequence", "HexadecimalFractionalConstant", "HexadecimalDigitSequence", "BinaryExponentPart", "EscapeSequence", "Whitespace", "Newline", } staticData.PredictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ - 4, 0, 68, 1232, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, + 4, 0, 74, 1374, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, @@ -100,114 +104,128 @@ func planlexerLexerInit() { 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, - 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 1, 0, 1, 0, - 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, - 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, - 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, - 1, 13, 1, 13, 3, 13, 226, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, - 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 240, 8, 14, 1, 15, - 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, - 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 262, - 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, - 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, - 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 288, 8, 16, 1, 17, 1, 17, 1, 17, 1, - 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, + 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 1, + 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, + 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, + 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, + 13, 1, 13, 1, 13, 1, 13, 3, 13, 238, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, + 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 252, 8, + 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, + 15, 274, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, + 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 300, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, - 17, 1, 17, 3, 17, 316, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, - 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, - 18, 334, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 342, 8, - 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, - 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 3, 17, 328, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, + 1, 18, 1, 18, 1, 18, 3, 18, 348, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, + 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, + 1, 19, 1, 19, 1, 19, 3, 19, 368, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, - 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 384, - 8, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, - 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, - 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, - 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 421, 8, 33, 1, 34, 1, 34, 1, 34, - 1, 34, 1, 34, 1, 34, 3, 34, 429, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, - 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, - 445, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, - 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, - 1, 36, 1, 36, 1, 36, 3, 36, 469, 8, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, - 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 480, 8, 38, 1, 39, 1, 39, 1, 39, - 1, 39, 3, 39, 486, 8, 39, 1, 40, 1, 40, 1, 40, 5, 40, 491, 8, 40, 10, 40, - 12, 40, 494, 9, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, + 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 392, 8, 20, 1, + 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, + 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 414, + 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, + 1, 22, 1, 22, 3, 22, 438, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, + 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, + 3, 23, 456, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 464, + 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, + 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, + 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, + 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, + 506, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, + 526, 8, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, + 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 35, + 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, + 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 563, 8, 39, 1, 40, 1, 40, + 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 571, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, - 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 3, - 41, 524, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, - 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, + 3, 41, 587, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, - 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 560, 8, 42, 1, 43, 1, 43, 1, - 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, - 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, - 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, - 3, 43, 596, 8, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, - 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, - 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, - 44, 626, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, - 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, - 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, - 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 664, 8, 45, 1, - 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, - 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, - 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, - 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 702, 8, 46, 1, 47, 1, 47, 1, 47, 1, + 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 611, 8, 42, 1, 43, 1, 43, 1, 44, 1, + 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 622, 8, 44, 1, 45, 1, 45, + 1, 45, 1, 45, 3, 45, 628, 8, 45, 1, 46, 1, 46, 1, 46, 5, 46, 633, 8, 46, + 10, 46, 12, 46, 636, 9, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, - 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, - 47, 728, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, + 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, + 47, 3, 47, 666, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, - 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, - 758, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, - 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, - 778, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, + 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, + 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 702, 8, 48, 1, 49, 1, + 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, + 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, + 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, + 1, 49, 3, 49, 738, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, - 1, 50, 3, 50, 800, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, + 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, + 50, 3, 50, 768, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, + 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, - 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 824, 8, 51, 1, 52, 1, 52, 1, + 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 806, 8, + 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, + 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, - 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 846, 8, 52, 1, + 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 844, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 870, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, - 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 898, - 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, - 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 918, - 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 3, 54, 900, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, + 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, + 3, 55, 920, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, - 3, 56, 940, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 1, 56, 1, 56, 3, 56, 942, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, - 1, 57, 1, 57, 3, 57, 962, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, + 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 966, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, - 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, - 58, 3, 58, 991, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 997, 8, 59, 1, - 60, 1, 60, 3, 60, 1001, 8, 60, 1, 61, 1, 61, 1, 61, 5, 61, 1006, 8, 61, - 10, 61, 12, 61, 1009, 9, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, - 1, 63, 3, 63, 1018, 8, 63, 1, 63, 1, 63, 3, 63, 1022, 8, 63, 1, 63, 1, - 63, 1, 63, 3, 63, 1027, 8, 63, 1, 63, 3, 63, 1030, 8, 63, 1, 64, 1, 64, - 3, 64, 1034, 8, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1039, 8, 64, 1, 64, 1, - 64, 4, 64, 1043, 8, 64, 11, 64, 12, 64, 1044, 1, 65, 1, 65, 1, 65, 1, 65, - 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 3, 66, 1056, 8, 66, 1, 67, 4, 67, 1059, - 8, 67, 11, 67, 12, 67, 1060, 1, 68, 4, 68, 1064, 8, 68, 11, 68, 12, 68, - 1065, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1075, 8, - 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1084, 8, 70, - 1, 71, 1, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 4, 73, 1093, 8, 73, 11, - 73, 12, 73, 1094, 1, 74, 1, 74, 5, 74, 1099, 8, 74, 10, 74, 12, 74, 1102, - 9, 74, 1, 74, 3, 74, 1105, 8, 74, 1, 75, 1, 75, 5, 75, 1109, 8, 75, 10, - 75, 12, 75, 1112, 9, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 78, - 1, 78, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, - 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1139, 8, 81, - 1, 82, 1, 82, 3, 82, 1143, 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1148, 8, - 82, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1154, 8, 83, 1, 83, 1, 83, 1, 84, - 3, 84, 1159, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1166, 8, - 84, 1, 85, 1, 85, 3, 85, 1170, 8, 85, 1, 85, 1, 85, 1, 86, 4, 86, 1175, - 8, 86, 11, 86, 12, 86, 1176, 1, 87, 3, 87, 1180, 8, 87, 1, 87, 1, 87, 1, - 87, 1, 87, 1, 87, 3, 87, 1187, 8, 87, 1, 88, 4, 88, 1190, 8, 88, 11, 88, - 12, 88, 1191, 1, 89, 1, 89, 3, 89, 1196, 8, 89, 1, 89, 1, 89, 1, 90, 1, - 90, 1, 90, 1, 90, 1, 90, 3, 90, 1205, 8, 90, 1, 90, 3, 90, 1208, 8, 90, - 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1215, 8, 90, 1, 91, 4, 91, 1218, - 8, 91, 11, 91, 12, 91, 1219, 1, 91, 1, 91, 1, 92, 1, 92, 3, 92, 1226, 8, - 92, 1, 92, 3, 92, 1229, 8, 92, 1, 92, 1, 92, 0, 0, 93, 1, 1, 3, 2, 5, 3, + 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 988, 8, + 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, + 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, + 59, 1, 59, 3, 59, 1012, 8, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, + 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, + 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, + 1040, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, + 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, + 1060, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, + 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, + 1, 62, 3, 62, 1082, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, + 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, + 1, 63, 1, 63, 1, 63, 3, 63, 1104, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, + 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, + 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, + 64, 1, 64, 3, 64, 1133, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1139, + 8, 65, 1, 66, 1, 66, 3, 66, 1143, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1148, + 8, 67, 10, 67, 12, 67, 1151, 9, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, + 1, 68, 1, 69, 3, 69, 1160, 8, 69, 1, 69, 1, 69, 3, 69, 1164, 8, 69, 1, + 69, 1, 69, 1, 69, 3, 69, 1169, 8, 69, 1, 69, 3, 69, 1172, 8, 69, 1, 70, + 1, 70, 3, 70, 1176, 8, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1181, 8, 70, 1, + 70, 1, 70, 4, 70, 1185, 8, 70, 11, 70, 12, 70, 1186, 1, 71, 1, 71, 1, 71, + 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 3, 72, 1198, 8, 72, 1, 73, 4, + 73, 1201, 8, 73, 11, 73, 12, 73, 1202, 1, 74, 4, 74, 1206, 8, 74, 11, 74, + 12, 74, 1207, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1217, + 8, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1226, 8, + 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 4, 79, 1235, 8, 79, + 11, 79, 12, 79, 1236, 1, 80, 1, 80, 5, 80, 1241, 8, 80, 10, 80, 12, 80, + 1244, 9, 80, 1, 80, 3, 80, 1247, 8, 80, 1, 81, 1, 81, 5, 81, 1251, 8, 81, + 10, 81, 12, 81, 1254, 9, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, + 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, + 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1281, + 8, 87, 1, 88, 1, 88, 3, 88, 1285, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1290, + 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1296, 8, 89, 1, 89, 1, 89, 1, + 90, 3, 90, 1301, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1308, + 8, 90, 1, 91, 1, 91, 3, 91, 1312, 8, 91, 1, 91, 1, 91, 1, 92, 4, 92, 1317, + 8, 92, 11, 92, 12, 92, 1318, 1, 93, 3, 93, 1322, 8, 93, 1, 93, 1, 93, 1, + 93, 1, 93, 1, 93, 3, 93, 1329, 8, 93, 1, 94, 4, 94, 1332, 8, 94, 11, 94, + 12, 94, 1333, 1, 95, 1, 95, 3, 95, 1338, 8, 95, 1, 95, 1, 95, 1, 96, 1, + 96, 1, 96, 1, 96, 1, 96, 3, 96, 1347, 8, 96, 1, 96, 3, 96, 1350, 8, 96, + 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1357, 8, 96, 1, 97, 4, 97, 1360, + 8, 97, 11, 97, 12, 97, 1361, 1, 97, 1, 97, 1, 98, 1, 98, 3, 98, 1368, 8, + 98, 1, 98, 3, 98, 1371, 8, 98, 1, 98, 1, 98, 0, 0, 99, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, @@ -215,434 +233,487 @@ func planlexerLexerInit() { 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, - 131, 66, 133, 0, 135, 0, 137, 0, 139, 0, 141, 0, 143, 0, 145, 0, 147, 0, - 149, 0, 151, 0, 153, 0, 155, 0, 157, 0, 159, 0, 161, 0, 163, 0, 165, 0, - 167, 0, 169, 0, 171, 0, 173, 0, 175, 0, 177, 0, 179, 0, 181, 0, 183, 67, - 185, 68, 1, 0, 16, 3, 0, 76, 76, 85, 85, 117, 117, 4, 0, 10, 10, 13, 13, - 34, 34, 92, 92, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 3, 0, 65, 90, 95, - 95, 97, 122, 1, 0, 48, 57, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 2, 0, 88, - 88, 120, 120, 1, 0, 49, 57, 1, 0, 48, 55, 3, 0, 48, 57, 65, 70, 97, 102, - 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 80, 80, 112, 112, 10, - 0, 34, 34, 39, 39, 63, 63, 92, 92, 97, 98, 102, 102, 110, 110, 114, 114, - 116, 116, 118, 118, 2, 0, 9, 9, 32, 32, 1293, 0, 1, 1, 0, 0, 0, 0, 3, 1, - 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, - 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, - 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, - 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, - 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, - 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, - 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, - 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, - 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, - 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, - 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, - 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, - 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, - 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, - 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, - 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, - 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, - 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 1, 187, 1, 0, 0, 0, 3, 189, - 1, 0, 0, 0, 5, 191, 1, 0, 0, 0, 7, 193, 1, 0, 0, 0, 9, 195, 1, 0, 0, 0, - 11, 197, 1, 0, 0, 0, 13, 199, 1, 0, 0, 0, 15, 201, 1, 0, 0, 0, 17, 203, - 1, 0, 0, 0, 19, 206, 1, 0, 0, 0, 21, 208, 1, 0, 0, 0, 23, 211, 1, 0, 0, - 0, 25, 214, 1, 0, 0, 0, 27, 225, 1, 0, 0, 0, 29, 239, 1, 0, 0, 0, 31, 261, - 1, 0, 0, 0, 33, 287, 1, 0, 0, 0, 35, 315, 1, 0, 0, 0, 37, 333, 1, 0, 0, - 0, 39, 341, 1, 0, 0, 0, 41, 383, 1, 0, 0, 0, 43, 385, 1, 0, 0, 0, 45, 387, - 1, 0, 0, 0, 47, 389, 1, 0, 0, 0, 49, 391, 1, 0, 0, 0, 51, 393, 1, 0, 0, - 0, 53, 395, 1, 0, 0, 0, 55, 397, 1, 0, 0, 0, 57, 400, 1, 0, 0, 0, 59, 403, - 1, 0, 0, 0, 61, 406, 1, 0, 0, 0, 63, 408, 1, 0, 0, 0, 65, 410, 1, 0, 0, - 0, 67, 420, 1, 0, 0, 0, 69, 428, 1, 0, 0, 0, 71, 444, 1, 0, 0, 0, 73, 468, - 1, 0, 0, 0, 75, 470, 1, 0, 0, 0, 77, 479, 1, 0, 0, 0, 79, 485, 1, 0, 0, - 0, 81, 487, 1, 0, 0, 0, 83, 523, 1, 0, 0, 0, 85, 559, 1, 0, 0, 0, 87, 595, - 1, 0, 0, 0, 89, 625, 1, 0, 0, 0, 91, 663, 1, 0, 0, 0, 93, 701, 1, 0, 0, - 0, 95, 727, 1, 0, 0, 0, 97, 757, 1, 0, 0, 0, 99, 777, 1, 0, 0, 0, 101, - 799, 1, 0, 0, 0, 103, 823, 1, 0, 0, 0, 105, 845, 1, 0, 0, 0, 107, 869, - 1, 0, 0, 0, 109, 897, 1, 0, 0, 0, 111, 917, 1, 0, 0, 0, 113, 939, 1, 0, - 0, 0, 115, 961, 1, 0, 0, 0, 117, 990, 1, 0, 0, 0, 119, 996, 1, 0, 0, 0, - 121, 1000, 1, 0, 0, 0, 123, 1002, 1, 0, 0, 0, 125, 1010, 1, 0, 0, 0, 127, - 1017, 1, 0, 0, 0, 129, 1033, 1, 0, 0, 0, 131, 1046, 1, 0, 0, 0, 133, 1055, - 1, 0, 0, 0, 135, 1058, 1, 0, 0, 0, 137, 1063, 1, 0, 0, 0, 139, 1074, 1, - 0, 0, 0, 141, 1083, 1, 0, 0, 0, 143, 1085, 1, 0, 0, 0, 145, 1087, 1, 0, - 0, 0, 147, 1089, 1, 0, 0, 0, 149, 1104, 1, 0, 0, 0, 151, 1106, 1, 0, 0, - 0, 153, 1113, 1, 0, 0, 0, 155, 1117, 1, 0, 0, 0, 157, 1119, 1, 0, 0, 0, - 159, 1121, 1, 0, 0, 0, 161, 1123, 1, 0, 0, 0, 163, 1138, 1, 0, 0, 0, 165, - 1147, 1, 0, 0, 0, 167, 1149, 1, 0, 0, 0, 169, 1165, 1, 0, 0, 0, 171, 1167, - 1, 0, 0, 0, 173, 1174, 1, 0, 0, 0, 175, 1186, 1, 0, 0, 0, 177, 1189, 1, - 0, 0, 0, 179, 1193, 1, 0, 0, 0, 181, 1214, 1, 0, 0, 0, 183, 1217, 1, 0, - 0, 0, 185, 1228, 1, 0, 0, 0, 187, 188, 5, 40, 0, 0, 188, 2, 1, 0, 0, 0, - 189, 190, 5, 41, 0, 0, 190, 4, 1, 0, 0, 0, 191, 192, 5, 91, 0, 0, 192, - 6, 1, 0, 0, 0, 193, 194, 5, 44, 0, 0, 194, 8, 1, 0, 0, 0, 195, 196, 5, - 93, 0, 0, 196, 10, 1, 0, 0, 0, 197, 198, 5, 123, 0, 0, 198, 12, 1, 0, 0, - 0, 199, 200, 5, 125, 0, 0, 200, 14, 1, 0, 0, 0, 201, 202, 5, 60, 0, 0, - 202, 16, 1, 0, 0, 0, 203, 204, 5, 60, 0, 0, 204, 205, 5, 61, 0, 0, 205, - 18, 1, 0, 0, 0, 206, 207, 5, 62, 0, 0, 207, 20, 1, 0, 0, 0, 208, 209, 5, - 62, 0, 0, 209, 210, 5, 61, 0, 0, 210, 22, 1, 0, 0, 0, 211, 212, 5, 61, - 0, 0, 212, 213, 5, 61, 0, 0, 213, 24, 1, 0, 0, 0, 214, 215, 5, 33, 0, 0, - 215, 216, 5, 61, 0, 0, 216, 26, 1, 0, 0, 0, 217, 218, 5, 108, 0, 0, 218, - 219, 5, 105, 0, 0, 219, 220, 5, 107, 0, 0, 220, 226, 5, 101, 0, 0, 221, - 222, 5, 76, 0, 0, 222, 223, 5, 73, 0, 0, 223, 224, 5, 75, 0, 0, 224, 226, - 5, 69, 0, 0, 225, 217, 1, 0, 0, 0, 225, 221, 1, 0, 0, 0, 226, 28, 1, 0, - 0, 0, 227, 228, 5, 101, 0, 0, 228, 229, 5, 120, 0, 0, 229, 230, 5, 105, - 0, 0, 230, 231, 5, 115, 0, 0, 231, 232, 5, 116, 0, 0, 232, 240, 5, 115, - 0, 0, 233, 234, 5, 69, 0, 0, 234, 235, 5, 88, 0, 0, 235, 236, 5, 73, 0, - 0, 236, 237, 5, 83, 0, 0, 237, 238, 5, 84, 0, 0, 238, 240, 5, 83, 0, 0, - 239, 227, 1, 0, 0, 0, 239, 233, 1, 0, 0, 0, 240, 30, 1, 0, 0, 0, 241, 242, - 5, 116, 0, 0, 242, 243, 5, 101, 0, 0, 243, 244, 5, 120, 0, 0, 244, 245, - 5, 116, 0, 0, 245, 246, 5, 95, 0, 0, 246, 247, 5, 109, 0, 0, 247, 248, - 5, 97, 0, 0, 248, 249, 5, 116, 0, 0, 249, 250, 5, 99, 0, 0, 250, 262, 5, - 104, 0, 0, 251, 252, 5, 84, 0, 0, 252, 253, 5, 69, 0, 0, 253, 254, 5, 88, - 0, 0, 254, 255, 5, 84, 0, 0, 255, 256, 5, 95, 0, 0, 256, 257, 5, 77, 0, - 0, 257, 258, 5, 65, 0, 0, 258, 259, 5, 84, 0, 0, 259, 260, 5, 67, 0, 0, - 260, 262, 5, 72, 0, 0, 261, 241, 1, 0, 0, 0, 261, 251, 1, 0, 0, 0, 262, - 32, 1, 0, 0, 0, 263, 264, 5, 112, 0, 0, 264, 265, 5, 104, 0, 0, 265, 266, - 5, 114, 0, 0, 266, 267, 5, 97, 0, 0, 267, 268, 5, 115, 0, 0, 268, 269, - 5, 101, 0, 0, 269, 270, 5, 95, 0, 0, 270, 271, 5, 109, 0, 0, 271, 272, - 5, 97, 0, 0, 272, 273, 5, 116, 0, 0, 273, 274, 5, 99, 0, 0, 274, 288, 5, - 104, 0, 0, 275, 276, 5, 80, 0, 0, 276, 277, 5, 72, 0, 0, 277, 278, 5, 82, - 0, 0, 278, 279, 5, 65, 0, 0, 279, 280, 5, 83, 0, 0, 280, 281, 5, 69, 0, - 0, 281, 282, 5, 95, 0, 0, 282, 283, 5, 77, 0, 0, 283, 284, 5, 65, 0, 0, - 284, 285, 5, 84, 0, 0, 285, 286, 5, 67, 0, 0, 286, 288, 5, 72, 0, 0, 287, - 263, 1, 0, 0, 0, 287, 275, 1, 0, 0, 0, 288, 34, 1, 0, 0, 0, 289, 290, 5, - 114, 0, 0, 290, 291, 5, 97, 0, 0, 291, 292, 5, 110, 0, 0, 292, 293, 5, - 100, 0, 0, 293, 294, 5, 111, 0, 0, 294, 295, 5, 109, 0, 0, 295, 296, 5, - 95, 0, 0, 296, 297, 5, 115, 0, 0, 297, 298, 5, 97, 0, 0, 298, 299, 5, 109, - 0, 0, 299, 300, 5, 112, 0, 0, 300, 301, 5, 108, 0, 0, 301, 316, 5, 101, - 0, 0, 302, 303, 5, 82, 0, 0, 303, 304, 5, 65, 0, 0, 304, 305, 5, 78, 0, - 0, 305, 306, 5, 68, 0, 0, 306, 307, 5, 79, 0, 0, 307, 308, 5, 77, 0, 0, - 308, 309, 5, 95, 0, 0, 309, 310, 5, 83, 0, 0, 310, 311, 5, 65, 0, 0, 311, - 312, 5, 77, 0, 0, 312, 313, 5, 80, 0, 0, 313, 314, 5, 76, 0, 0, 314, 316, - 5, 69, 0, 0, 315, 289, 1, 0, 0, 0, 315, 302, 1, 0, 0, 0, 316, 36, 1, 0, - 0, 0, 317, 318, 5, 105, 0, 0, 318, 319, 5, 110, 0, 0, 319, 320, 5, 116, - 0, 0, 320, 321, 5, 101, 0, 0, 321, 322, 5, 114, 0, 0, 322, 323, 5, 118, - 0, 0, 323, 324, 5, 97, 0, 0, 324, 334, 5, 108, 0, 0, 325, 326, 5, 73, 0, - 0, 326, 327, 5, 78, 0, 0, 327, 328, 5, 84, 0, 0, 328, 329, 5, 69, 0, 0, - 329, 330, 5, 82, 0, 0, 330, 331, 5, 86, 0, 0, 331, 332, 5, 65, 0, 0, 332, - 334, 5, 76, 0, 0, 333, 317, 1, 0, 0, 0, 333, 325, 1, 0, 0, 0, 334, 38, - 1, 0, 0, 0, 335, 336, 5, 105, 0, 0, 336, 337, 5, 115, 0, 0, 337, 342, 5, - 111, 0, 0, 338, 339, 5, 73, 0, 0, 339, 340, 5, 83, 0, 0, 340, 342, 5, 79, - 0, 0, 341, 335, 1, 0, 0, 0, 341, 338, 1, 0, 0, 0, 342, 40, 1, 0, 0, 0, - 343, 344, 5, 109, 0, 0, 344, 345, 5, 105, 0, 0, 345, 346, 5, 110, 0, 0, - 346, 347, 5, 105, 0, 0, 347, 348, 5, 109, 0, 0, 348, 349, 5, 117, 0, 0, - 349, 350, 5, 109, 0, 0, 350, 351, 5, 95, 0, 0, 351, 352, 5, 115, 0, 0, - 352, 353, 5, 104, 0, 0, 353, 354, 5, 111, 0, 0, 354, 355, 5, 117, 0, 0, - 355, 356, 5, 108, 0, 0, 356, 357, 5, 100, 0, 0, 357, 358, 5, 95, 0, 0, - 358, 359, 5, 109, 0, 0, 359, 360, 5, 97, 0, 0, 360, 361, 5, 116, 0, 0, - 361, 362, 5, 99, 0, 0, 362, 384, 5, 104, 0, 0, 363, 364, 5, 77, 0, 0, 364, - 365, 5, 73, 0, 0, 365, 366, 5, 78, 0, 0, 366, 367, 5, 73, 0, 0, 367, 368, - 5, 77, 0, 0, 368, 369, 5, 85, 0, 0, 369, 370, 5, 77, 0, 0, 370, 371, 5, - 95, 0, 0, 371, 372, 5, 83, 0, 0, 372, 373, 5, 72, 0, 0, 373, 374, 5, 79, - 0, 0, 374, 375, 5, 85, 0, 0, 375, 376, 5, 76, 0, 0, 376, 377, 5, 68, 0, - 0, 377, 378, 5, 95, 0, 0, 378, 379, 5, 77, 0, 0, 379, 380, 5, 65, 0, 0, - 380, 381, 5, 84, 0, 0, 381, 382, 5, 67, 0, 0, 382, 384, 5, 72, 0, 0, 383, - 343, 1, 0, 0, 0, 383, 363, 1, 0, 0, 0, 384, 42, 1, 0, 0, 0, 385, 386, 5, - 61, 0, 0, 386, 44, 1, 0, 0, 0, 387, 388, 5, 43, 0, 0, 388, 46, 1, 0, 0, - 0, 389, 390, 5, 45, 0, 0, 390, 48, 1, 0, 0, 0, 391, 392, 5, 42, 0, 0, 392, - 50, 1, 0, 0, 0, 393, 394, 5, 47, 0, 0, 394, 52, 1, 0, 0, 0, 395, 396, 5, - 37, 0, 0, 396, 54, 1, 0, 0, 0, 397, 398, 5, 42, 0, 0, 398, 399, 5, 42, - 0, 0, 399, 56, 1, 0, 0, 0, 400, 401, 5, 60, 0, 0, 401, 402, 5, 60, 0, 0, - 402, 58, 1, 0, 0, 0, 403, 404, 5, 62, 0, 0, 404, 405, 5, 62, 0, 0, 405, - 60, 1, 0, 0, 0, 406, 407, 5, 38, 0, 0, 407, 62, 1, 0, 0, 0, 408, 409, 5, - 124, 0, 0, 409, 64, 1, 0, 0, 0, 410, 411, 5, 94, 0, 0, 411, 66, 1, 0, 0, - 0, 412, 413, 5, 38, 0, 0, 413, 421, 5, 38, 0, 0, 414, 415, 5, 97, 0, 0, - 415, 416, 5, 110, 0, 0, 416, 421, 5, 100, 0, 0, 417, 418, 5, 65, 0, 0, - 418, 419, 5, 78, 0, 0, 419, 421, 5, 68, 0, 0, 420, 412, 1, 0, 0, 0, 420, - 414, 1, 0, 0, 0, 420, 417, 1, 0, 0, 0, 421, 68, 1, 0, 0, 0, 422, 423, 5, - 124, 0, 0, 423, 429, 5, 124, 0, 0, 424, 425, 5, 111, 0, 0, 425, 429, 5, - 114, 0, 0, 426, 427, 5, 79, 0, 0, 427, 429, 5, 82, 0, 0, 428, 422, 1, 0, - 0, 0, 428, 424, 1, 0, 0, 0, 428, 426, 1, 0, 0, 0, 429, 70, 1, 0, 0, 0, - 430, 431, 5, 105, 0, 0, 431, 432, 5, 115, 0, 0, 432, 433, 5, 32, 0, 0, - 433, 434, 5, 110, 0, 0, 434, 435, 5, 117, 0, 0, 435, 436, 5, 108, 0, 0, - 436, 445, 5, 108, 0, 0, 437, 438, 5, 73, 0, 0, 438, 439, 5, 83, 0, 0, 439, - 440, 5, 32, 0, 0, 440, 441, 5, 78, 0, 0, 441, 442, 5, 85, 0, 0, 442, 443, - 5, 76, 0, 0, 443, 445, 5, 76, 0, 0, 444, 430, 1, 0, 0, 0, 444, 437, 1, - 0, 0, 0, 445, 72, 1, 0, 0, 0, 446, 447, 5, 105, 0, 0, 447, 448, 5, 115, - 0, 0, 448, 449, 5, 32, 0, 0, 449, 450, 5, 110, 0, 0, 450, 451, 5, 111, - 0, 0, 451, 452, 5, 116, 0, 0, 452, 453, 5, 32, 0, 0, 453, 454, 5, 110, - 0, 0, 454, 455, 5, 117, 0, 0, 455, 456, 5, 108, 0, 0, 456, 469, 5, 108, - 0, 0, 457, 458, 5, 73, 0, 0, 458, 459, 5, 83, 0, 0, 459, 460, 5, 32, 0, - 0, 460, 461, 5, 78, 0, 0, 461, 462, 5, 79, 0, 0, 462, 463, 5, 84, 0, 0, - 463, 464, 5, 32, 0, 0, 464, 465, 5, 78, 0, 0, 465, 466, 5, 85, 0, 0, 466, - 467, 5, 76, 0, 0, 467, 469, 5, 76, 0, 0, 468, 446, 1, 0, 0, 0, 468, 457, - 1, 0, 0, 0, 469, 74, 1, 0, 0, 0, 470, 471, 5, 126, 0, 0, 471, 76, 1, 0, - 0, 0, 472, 480, 5, 33, 0, 0, 473, 474, 5, 110, 0, 0, 474, 475, 5, 111, - 0, 0, 475, 480, 5, 116, 0, 0, 476, 477, 5, 78, 0, 0, 477, 478, 5, 79, 0, - 0, 478, 480, 5, 84, 0, 0, 479, 472, 1, 0, 0, 0, 479, 473, 1, 0, 0, 0, 479, - 476, 1, 0, 0, 0, 480, 78, 1, 0, 0, 0, 481, 482, 5, 105, 0, 0, 482, 486, - 5, 110, 0, 0, 483, 484, 5, 73, 0, 0, 484, 486, 5, 78, 0, 0, 485, 481, 1, - 0, 0, 0, 485, 483, 1, 0, 0, 0, 486, 80, 1, 0, 0, 0, 487, 492, 5, 91, 0, - 0, 488, 491, 3, 183, 91, 0, 489, 491, 3, 185, 92, 0, 490, 488, 1, 0, 0, - 0, 490, 489, 1, 0, 0, 0, 491, 494, 1, 0, 0, 0, 492, 490, 1, 0, 0, 0, 492, - 493, 1, 0, 0, 0, 493, 495, 1, 0, 0, 0, 494, 492, 1, 0, 0, 0, 495, 496, - 5, 93, 0, 0, 496, 82, 1, 0, 0, 0, 497, 498, 5, 106, 0, 0, 498, 499, 5, - 115, 0, 0, 499, 500, 5, 111, 0, 0, 500, 501, 5, 110, 0, 0, 501, 502, 5, - 95, 0, 0, 502, 503, 5, 99, 0, 0, 503, 504, 5, 111, 0, 0, 504, 505, 5, 110, - 0, 0, 505, 506, 5, 116, 0, 0, 506, 507, 5, 97, 0, 0, 507, 508, 5, 105, - 0, 0, 508, 509, 5, 110, 0, 0, 509, 524, 5, 115, 0, 0, 510, 511, 5, 74, - 0, 0, 511, 512, 5, 83, 0, 0, 512, 513, 5, 79, 0, 0, 513, 514, 5, 78, 0, - 0, 514, 515, 5, 95, 0, 0, 515, 516, 5, 67, 0, 0, 516, 517, 5, 79, 0, 0, - 517, 518, 5, 78, 0, 0, 518, 519, 5, 84, 0, 0, 519, 520, 5, 65, 0, 0, 520, - 521, 5, 73, 0, 0, 521, 522, 5, 78, 0, 0, 522, 524, 5, 83, 0, 0, 523, 497, - 1, 0, 0, 0, 523, 510, 1, 0, 0, 0, 524, 84, 1, 0, 0, 0, 525, 526, 5, 106, - 0, 0, 526, 527, 5, 115, 0, 0, 527, 528, 5, 111, 0, 0, 528, 529, 5, 110, - 0, 0, 529, 530, 5, 95, 0, 0, 530, 531, 5, 99, 0, 0, 531, 532, 5, 111, 0, - 0, 532, 533, 5, 110, 0, 0, 533, 534, 5, 116, 0, 0, 534, 535, 5, 97, 0, - 0, 535, 536, 5, 105, 0, 0, 536, 537, 5, 110, 0, 0, 537, 538, 5, 115, 0, - 0, 538, 539, 5, 95, 0, 0, 539, 540, 5, 97, 0, 0, 540, 541, 5, 108, 0, 0, - 541, 560, 5, 108, 0, 0, 542, 543, 5, 74, 0, 0, 543, 544, 5, 83, 0, 0, 544, - 545, 5, 79, 0, 0, 545, 546, 5, 78, 0, 0, 546, 547, 5, 95, 0, 0, 547, 548, - 5, 67, 0, 0, 548, 549, 5, 79, 0, 0, 549, 550, 5, 78, 0, 0, 550, 551, 5, - 84, 0, 0, 551, 552, 5, 65, 0, 0, 552, 553, 5, 73, 0, 0, 553, 554, 5, 78, - 0, 0, 554, 555, 5, 83, 0, 0, 555, 556, 5, 95, 0, 0, 556, 557, 5, 65, 0, - 0, 557, 558, 5, 76, 0, 0, 558, 560, 5, 76, 0, 0, 559, 525, 1, 0, 0, 0, - 559, 542, 1, 0, 0, 0, 560, 86, 1, 0, 0, 0, 561, 562, 5, 106, 0, 0, 562, - 563, 5, 115, 0, 0, 563, 564, 5, 111, 0, 0, 564, 565, 5, 110, 0, 0, 565, - 566, 5, 95, 0, 0, 566, 567, 5, 99, 0, 0, 567, 568, 5, 111, 0, 0, 568, 569, - 5, 110, 0, 0, 569, 570, 5, 116, 0, 0, 570, 571, 5, 97, 0, 0, 571, 572, - 5, 105, 0, 0, 572, 573, 5, 110, 0, 0, 573, 574, 5, 115, 0, 0, 574, 575, - 5, 95, 0, 0, 575, 576, 5, 97, 0, 0, 576, 577, 5, 110, 0, 0, 577, 596, 5, - 121, 0, 0, 578, 579, 5, 74, 0, 0, 579, 580, 5, 83, 0, 0, 580, 581, 5, 79, - 0, 0, 581, 582, 5, 78, 0, 0, 582, 583, 5, 95, 0, 0, 583, 584, 5, 67, 0, - 0, 584, 585, 5, 79, 0, 0, 585, 586, 5, 78, 0, 0, 586, 587, 5, 84, 0, 0, - 587, 588, 5, 65, 0, 0, 588, 589, 5, 73, 0, 0, 589, 590, 5, 78, 0, 0, 590, - 591, 5, 83, 0, 0, 591, 592, 5, 95, 0, 0, 592, 593, 5, 65, 0, 0, 593, 594, - 5, 78, 0, 0, 594, 596, 5, 89, 0, 0, 595, 561, 1, 0, 0, 0, 595, 578, 1, - 0, 0, 0, 596, 88, 1, 0, 0, 0, 597, 598, 5, 97, 0, 0, 598, 599, 5, 114, - 0, 0, 599, 600, 5, 114, 0, 0, 600, 601, 5, 97, 0, 0, 601, 602, 5, 121, - 0, 0, 602, 603, 5, 95, 0, 0, 603, 604, 5, 99, 0, 0, 604, 605, 5, 111, 0, - 0, 605, 606, 5, 110, 0, 0, 606, 607, 5, 116, 0, 0, 607, 608, 5, 97, 0, - 0, 608, 609, 5, 105, 0, 0, 609, 610, 5, 110, 0, 0, 610, 626, 5, 115, 0, - 0, 611, 612, 5, 65, 0, 0, 612, 613, 5, 82, 0, 0, 613, 614, 5, 82, 0, 0, - 614, 615, 5, 65, 0, 0, 615, 616, 5, 89, 0, 0, 616, 617, 5, 95, 0, 0, 617, - 618, 5, 67, 0, 0, 618, 619, 5, 79, 0, 0, 619, 620, 5, 78, 0, 0, 620, 621, - 5, 84, 0, 0, 621, 622, 5, 65, 0, 0, 622, 623, 5, 73, 0, 0, 623, 624, 5, - 78, 0, 0, 624, 626, 5, 83, 0, 0, 625, 597, 1, 0, 0, 0, 625, 611, 1, 0, - 0, 0, 626, 90, 1, 0, 0, 0, 627, 628, 5, 97, 0, 0, 628, 629, 5, 114, 0, - 0, 629, 630, 5, 114, 0, 0, 630, 631, 5, 97, 0, 0, 631, 632, 5, 121, 0, - 0, 632, 633, 5, 95, 0, 0, 633, 634, 5, 99, 0, 0, 634, 635, 5, 111, 0, 0, - 635, 636, 5, 110, 0, 0, 636, 637, 5, 116, 0, 0, 637, 638, 5, 97, 0, 0, - 638, 639, 5, 105, 0, 0, 639, 640, 5, 110, 0, 0, 640, 641, 5, 115, 0, 0, - 641, 642, 5, 95, 0, 0, 642, 643, 5, 97, 0, 0, 643, 644, 5, 108, 0, 0, 644, - 664, 5, 108, 0, 0, 645, 646, 5, 65, 0, 0, 646, 647, 5, 82, 0, 0, 647, 648, - 5, 82, 0, 0, 648, 649, 5, 65, 0, 0, 649, 650, 5, 89, 0, 0, 650, 651, 5, - 95, 0, 0, 651, 652, 5, 67, 0, 0, 652, 653, 5, 79, 0, 0, 653, 654, 5, 78, - 0, 0, 654, 655, 5, 84, 0, 0, 655, 656, 5, 65, 0, 0, 656, 657, 5, 73, 0, - 0, 657, 658, 5, 78, 0, 0, 658, 659, 5, 83, 0, 0, 659, 660, 5, 95, 0, 0, - 660, 661, 5, 65, 0, 0, 661, 662, 5, 76, 0, 0, 662, 664, 5, 76, 0, 0, 663, - 627, 1, 0, 0, 0, 663, 645, 1, 0, 0, 0, 664, 92, 1, 0, 0, 0, 665, 666, 5, - 97, 0, 0, 666, 667, 5, 114, 0, 0, 667, 668, 5, 114, 0, 0, 668, 669, 5, - 97, 0, 0, 669, 670, 5, 121, 0, 0, 670, 671, 5, 95, 0, 0, 671, 672, 5, 99, - 0, 0, 672, 673, 5, 111, 0, 0, 673, 674, 5, 110, 0, 0, 674, 675, 5, 116, - 0, 0, 675, 676, 5, 97, 0, 0, 676, 677, 5, 105, 0, 0, 677, 678, 5, 110, - 0, 0, 678, 679, 5, 115, 0, 0, 679, 680, 5, 95, 0, 0, 680, 681, 5, 97, 0, - 0, 681, 682, 5, 110, 0, 0, 682, 702, 5, 121, 0, 0, 683, 684, 5, 65, 0, - 0, 684, 685, 5, 82, 0, 0, 685, 686, 5, 82, 0, 0, 686, 687, 5, 65, 0, 0, - 687, 688, 5, 89, 0, 0, 688, 689, 5, 95, 0, 0, 689, 690, 5, 67, 0, 0, 690, - 691, 5, 79, 0, 0, 691, 692, 5, 78, 0, 0, 692, 693, 5, 84, 0, 0, 693, 694, - 5, 65, 0, 0, 694, 695, 5, 73, 0, 0, 695, 696, 5, 78, 0, 0, 696, 697, 5, - 83, 0, 0, 697, 698, 5, 95, 0, 0, 698, 699, 5, 65, 0, 0, 699, 700, 5, 78, - 0, 0, 700, 702, 5, 89, 0, 0, 701, 665, 1, 0, 0, 0, 701, 683, 1, 0, 0, 0, - 702, 94, 1, 0, 0, 0, 703, 704, 5, 97, 0, 0, 704, 705, 5, 114, 0, 0, 705, - 706, 5, 114, 0, 0, 706, 707, 5, 97, 0, 0, 707, 708, 5, 121, 0, 0, 708, - 709, 5, 95, 0, 0, 709, 710, 5, 108, 0, 0, 710, 711, 5, 101, 0, 0, 711, - 712, 5, 110, 0, 0, 712, 713, 5, 103, 0, 0, 713, 714, 5, 116, 0, 0, 714, - 728, 5, 104, 0, 0, 715, 716, 5, 65, 0, 0, 716, 717, 5, 82, 0, 0, 717, 718, - 5, 82, 0, 0, 718, 719, 5, 65, 0, 0, 719, 720, 5, 89, 0, 0, 720, 721, 5, - 95, 0, 0, 721, 722, 5, 76, 0, 0, 722, 723, 5, 69, 0, 0, 723, 724, 5, 78, - 0, 0, 724, 725, 5, 71, 0, 0, 725, 726, 5, 84, 0, 0, 726, 728, 5, 72, 0, - 0, 727, 703, 1, 0, 0, 0, 727, 715, 1, 0, 0, 0, 728, 96, 1, 0, 0, 0, 729, - 730, 5, 101, 0, 0, 730, 731, 5, 108, 0, 0, 731, 732, 5, 101, 0, 0, 732, - 733, 5, 109, 0, 0, 733, 734, 5, 101, 0, 0, 734, 735, 5, 110, 0, 0, 735, - 736, 5, 116, 0, 0, 736, 737, 5, 95, 0, 0, 737, 738, 5, 102, 0, 0, 738, - 739, 5, 105, 0, 0, 739, 740, 5, 108, 0, 0, 740, 741, 5, 116, 0, 0, 741, - 742, 5, 101, 0, 0, 742, 758, 5, 114, 0, 0, 743, 744, 5, 69, 0, 0, 744, - 745, 5, 76, 0, 0, 745, 746, 5, 69, 0, 0, 746, 747, 5, 77, 0, 0, 747, 748, - 5, 69, 0, 0, 748, 749, 5, 78, 0, 0, 749, 750, 5, 84, 0, 0, 750, 751, 5, - 95, 0, 0, 751, 752, 5, 70, 0, 0, 752, 753, 5, 73, 0, 0, 753, 754, 5, 76, - 0, 0, 754, 755, 5, 84, 0, 0, 755, 756, 5, 69, 0, 0, 756, 758, 5, 82, 0, - 0, 757, 729, 1, 0, 0, 0, 757, 743, 1, 0, 0, 0, 758, 98, 1, 0, 0, 0, 759, - 760, 5, 115, 0, 0, 760, 761, 5, 116, 0, 0, 761, 762, 5, 95, 0, 0, 762, - 763, 5, 101, 0, 0, 763, 764, 5, 113, 0, 0, 764, 765, 5, 117, 0, 0, 765, - 766, 5, 97, 0, 0, 766, 767, 5, 108, 0, 0, 767, 778, 5, 115, 0, 0, 768, - 769, 5, 83, 0, 0, 769, 770, 5, 84, 0, 0, 770, 771, 5, 95, 0, 0, 771, 772, - 5, 69, 0, 0, 772, 773, 5, 81, 0, 0, 773, 774, 5, 85, 0, 0, 774, 775, 5, - 65, 0, 0, 775, 776, 5, 76, 0, 0, 776, 778, 5, 83, 0, 0, 777, 759, 1, 0, - 0, 0, 777, 768, 1, 0, 0, 0, 778, 100, 1, 0, 0, 0, 779, 780, 5, 115, 0, - 0, 780, 781, 5, 116, 0, 0, 781, 782, 5, 95, 0, 0, 782, 783, 5, 116, 0, - 0, 783, 784, 5, 111, 0, 0, 784, 785, 5, 117, 0, 0, 785, 786, 5, 99, 0, - 0, 786, 787, 5, 104, 0, 0, 787, 788, 5, 101, 0, 0, 788, 800, 5, 115, 0, - 0, 789, 790, 5, 83, 0, 0, 790, 791, 5, 84, 0, 0, 791, 792, 5, 95, 0, 0, - 792, 793, 5, 84, 0, 0, 793, 794, 5, 79, 0, 0, 794, 795, 5, 85, 0, 0, 795, - 796, 5, 67, 0, 0, 796, 797, 5, 72, 0, 0, 797, 798, 5, 69, 0, 0, 798, 800, - 5, 83, 0, 0, 799, 779, 1, 0, 0, 0, 799, 789, 1, 0, 0, 0, 800, 102, 1, 0, - 0, 0, 801, 802, 5, 115, 0, 0, 802, 803, 5, 116, 0, 0, 803, 804, 5, 95, - 0, 0, 804, 805, 5, 111, 0, 0, 805, 806, 5, 118, 0, 0, 806, 807, 5, 101, - 0, 0, 807, 808, 5, 114, 0, 0, 808, 809, 5, 108, 0, 0, 809, 810, 5, 97, - 0, 0, 810, 811, 5, 112, 0, 0, 811, 824, 5, 115, 0, 0, 812, 813, 5, 83, - 0, 0, 813, 814, 5, 84, 0, 0, 814, 815, 5, 95, 0, 0, 815, 816, 5, 79, 0, - 0, 816, 817, 5, 86, 0, 0, 817, 818, 5, 69, 0, 0, 818, 819, 5, 82, 0, 0, - 819, 820, 5, 76, 0, 0, 820, 821, 5, 65, 0, 0, 821, 822, 5, 80, 0, 0, 822, - 824, 5, 83, 0, 0, 823, 801, 1, 0, 0, 0, 823, 812, 1, 0, 0, 0, 824, 104, - 1, 0, 0, 0, 825, 826, 5, 115, 0, 0, 826, 827, 5, 116, 0, 0, 827, 828, 5, - 95, 0, 0, 828, 829, 5, 99, 0, 0, 829, 830, 5, 114, 0, 0, 830, 831, 5, 111, - 0, 0, 831, 832, 5, 115, 0, 0, 832, 833, 5, 115, 0, 0, 833, 834, 5, 101, - 0, 0, 834, 846, 5, 115, 0, 0, 835, 836, 5, 83, 0, 0, 836, 837, 5, 84, 0, - 0, 837, 838, 5, 95, 0, 0, 838, 839, 5, 67, 0, 0, 839, 840, 5, 82, 0, 0, - 840, 841, 5, 79, 0, 0, 841, 842, 5, 83, 0, 0, 842, 843, 5, 83, 0, 0, 843, - 844, 5, 69, 0, 0, 844, 846, 5, 83, 0, 0, 845, 825, 1, 0, 0, 0, 845, 835, - 1, 0, 0, 0, 846, 106, 1, 0, 0, 0, 847, 848, 5, 115, 0, 0, 848, 849, 5, - 116, 0, 0, 849, 850, 5, 95, 0, 0, 850, 851, 5, 99, 0, 0, 851, 852, 5, 111, - 0, 0, 852, 853, 5, 110, 0, 0, 853, 854, 5, 116, 0, 0, 854, 855, 5, 97, - 0, 0, 855, 856, 5, 105, 0, 0, 856, 857, 5, 110, 0, 0, 857, 870, 5, 115, - 0, 0, 858, 859, 5, 83, 0, 0, 859, 860, 5, 84, 0, 0, 860, 861, 5, 95, 0, - 0, 861, 862, 5, 67, 0, 0, 862, 863, 5, 79, 0, 0, 863, 864, 5, 78, 0, 0, - 864, 865, 5, 84, 0, 0, 865, 866, 5, 65, 0, 0, 866, 867, 5, 73, 0, 0, 867, - 868, 5, 78, 0, 0, 868, 870, 5, 83, 0, 0, 869, 847, 1, 0, 0, 0, 869, 858, - 1, 0, 0, 0, 870, 108, 1, 0, 0, 0, 871, 872, 5, 115, 0, 0, 872, 873, 5, - 116, 0, 0, 873, 874, 5, 95, 0, 0, 874, 875, 5, 105, 0, 0, 875, 876, 5, - 110, 0, 0, 876, 877, 5, 116, 0, 0, 877, 878, 5, 101, 0, 0, 878, 879, 5, - 114, 0, 0, 879, 880, 5, 115, 0, 0, 880, 881, 5, 101, 0, 0, 881, 882, 5, - 99, 0, 0, 882, 883, 5, 116, 0, 0, 883, 898, 5, 115, 0, 0, 884, 885, 5, - 83, 0, 0, 885, 886, 5, 84, 0, 0, 886, 887, 5, 95, 0, 0, 887, 888, 5, 73, - 0, 0, 888, 889, 5, 78, 0, 0, 889, 890, 5, 84, 0, 0, 890, 891, 5, 69, 0, - 0, 891, 892, 5, 82, 0, 0, 892, 893, 5, 83, 0, 0, 893, 894, 5, 69, 0, 0, - 894, 895, 5, 67, 0, 0, 895, 896, 5, 84, 0, 0, 896, 898, 5, 83, 0, 0, 897, - 871, 1, 0, 0, 0, 897, 884, 1, 0, 0, 0, 898, 110, 1, 0, 0, 0, 899, 900, - 5, 115, 0, 0, 900, 901, 5, 116, 0, 0, 901, 902, 5, 95, 0, 0, 902, 903, - 5, 119, 0, 0, 903, 904, 5, 105, 0, 0, 904, 905, 5, 116, 0, 0, 905, 906, - 5, 104, 0, 0, 906, 907, 5, 105, 0, 0, 907, 918, 5, 110, 0, 0, 908, 909, - 5, 83, 0, 0, 909, 910, 5, 84, 0, 0, 910, 911, 5, 95, 0, 0, 911, 912, 5, - 87, 0, 0, 912, 913, 5, 73, 0, 0, 913, 914, 5, 84, 0, 0, 914, 915, 5, 72, - 0, 0, 915, 916, 5, 73, 0, 0, 916, 918, 5, 78, 0, 0, 917, 899, 1, 0, 0, - 0, 917, 908, 1, 0, 0, 0, 918, 112, 1, 0, 0, 0, 919, 920, 5, 115, 0, 0, - 920, 921, 5, 116, 0, 0, 921, 922, 5, 95, 0, 0, 922, 923, 5, 100, 0, 0, - 923, 924, 5, 119, 0, 0, 924, 925, 5, 105, 0, 0, 925, 926, 5, 116, 0, 0, - 926, 927, 5, 104, 0, 0, 927, 928, 5, 105, 0, 0, 928, 940, 5, 110, 0, 0, - 929, 930, 5, 83, 0, 0, 930, 931, 5, 84, 0, 0, 931, 932, 5, 95, 0, 0, 932, - 933, 5, 68, 0, 0, 933, 934, 5, 87, 0, 0, 934, 935, 5, 73, 0, 0, 935, 936, - 5, 84, 0, 0, 936, 937, 5, 72, 0, 0, 937, 938, 5, 73, 0, 0, 938, 940, 5, - 78, 0, 0, 939, 919, 1, 0, 0, 0, 939, 929, 1, 0, 0, 0, 940, 114, 1, 0, 0, - 0, 941, 942, 5, 115, 0, 0, 942, 943, 5, 116, 0, 0, 943, 944, 5, 95, 0, - 0, 944, 945, 5, 105, 0, 0, 945, 946, 5, 115, 0, 0, 946, 947, 5, 118, 0, - 0, 947, 948, 5, 97, 0, 0, 948, 949, 5, 108, 0, 0, 949, 950, 5, 105, 0, - 0, 950, 962, 5, 100, 0, 0, 951, 952, 5, 83, 0, 0, 952, 953, 5, 84, 0, 0, - 953, 954, 5, 95, 0, 0, 954, 955, 5, 73, 0, 0, 955, 956, 5, 83, 0, 0, 956, - 957, 5, 86, 0, 0, 957, 958, 5, 65, 0, 0, 958, 959, 5, 76, 0, 0, 959, 960, - 5, 73, 0, 0, 960, 962, 5, 68, 0, 0, 961, 941, 1, 0, 0, 0, 961, 951, 1, - 0, 0, 0, 962, 116, 1, 0, 0, 0, 963, 964, 5, 116, 0, 0, 964, 965, 5, 114, - 0, 0, 965, 966, 5, 117, 0, 0, 966, 991, 5, 101, 0, 0, 967, 968, 5, 84, - 0, 0, 968, 969, 5, 114, 0, 0, 969, 970, 5, 117, 0, 0, 970, 991, 5, 101, - 0, 0, 971, 972, 5, 84, 0, 0, 972, 973, 5, 82, 0, 0, 973, 974, 5, 85, 0, - 0, 974, 991, 5, 69, 0, 0, 975, 976, 5, 102, 0, 0, 976, 977, 5, 97, 0, 0, - 977, 978, 5, 108, 0, 0, 978, 979, 5, 115, 0, 0, 979, 991, 5, 101, 0, 0, - 980, 981, 5, 70, 0, 0, 981, 982, 5, 97, 0, 0, 982, 983, 5, 108, 0, 0, 983, - 984, 5, 115, 0, 0, 984, 991, 5, 101, 0, 0, 985, 986, 5, 70, 0, 0, 986, - 987, 5, 65, 0, 0, 987, 988, 5, 76, 0, 0, 988, 989, 5, 83, 0, 0, 989, 991, - 5, 69, 0, 0, 990, 963, 1, 0, 0, 0, 990, 967, 1, 0, 0, 0, 990, 971, 1, 0, - 0, 0, 990, 975, 1, 0, 0, 0, 990, 980, 1, 0, 0, 0, 990, 985, 1, 0, 0, 0, - 991, 118, 1, 0, 0, 0, 992, 997, 3, 149, 74, 0, 993, 997, 3, 151, 75, 0, - 994, 997, 3, 153, 76, 0, 995, 997, 3, 147, 73, 0, 996, 992, 1, 0, 0, 0, - 996, 993, 1, 0, 0, 0, 996, 994, 1, 0, 0, 0, 996, 995, 1, 0, 0, 0, 997, - 120, 1, 0, 0, 0, 998, 1001, 3, 165, 82, 0, 999, 1001, 3, 167, 83, 0, 1000, - 998, 1, 0, 0, 0, 1000, 999, 1, 0, 0, 0, 1001, 122, 1, 0, 0, 0, 1002, 1007, - 3, 143, 71, 0, 1003, 1006, 3, 143, 71, 0, 1004, 1006, 3, 145, 72, 0, 1005, - 1003, 1, 0, 0, 0, 1005, 1004, 1, 0, 0, 0, 1006, 1009, 1, 0, 0, 0, 1007, - 1005, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 124, 1, 0, 0, 0, 1009, - 1007, 1, 0, 0, 0, 1010, 1011, 5, 36, 0, 0, 1011, 1012, 5, 109, 0, 0, 1012, - 1013, 5, 101, 0, 0, 1013, 1014, 5, 116, 0, 0, 1014, 1015, 5, 97, 0, 0, - 1015, 126, 1, 0, 0, 0, 1016, 1018, 3, 133, 66, 0, 1017, 1016, 1, 0, 0, - 0, 1017, 1018, 1, 0, 0, 0, 1018, 1029, 1, 0, 0, 0, 1019, 1021, 5, 34, 0, - 0, 1020, 1022, 3, 135, 67, 0, 1021, 1020, 1, 0, 0, 0, 1021, 1022, 1, 0, - 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1030, 5, 34, 0, 0, 1024, 1026, 5, 39, - 0, 0, 1025, 1027, 3, 137, 68, 0, 1026, 1025, 1, 0, 0, 0, 1026, 1027, 1, - 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 1030, 5, 39, 0, 0, 1029, 1019, 1, - 0, 0, 0, 1029, 1024, 1, 0, 0, 0, 1030, 128, 1, 0, 0, 0, 1031, 1034, 3, - 123, 61, 0, 1032, 1034, 3, 125, 62, 0, 1033, 1031, 1, 0, 0, 0, 1033, 1032, - 1, 0, 0, 0, 1034, 1042, 1, 0, 0, 0, 1035, 1038, 5, 91, 0, 0, 1036, 1039, - 3, 127, 63, 0, 1037, 1039, 3, 149, 74, 0, 1038, 1036, 1, 0, 0, 0, 1038, - 1037, 1, 0, 0, 0, 1039, 1040, 1, 0, 0, 0, 1040, 1041, 5, 93, 0, 0, 1041, - 1043, 1, 0, 0, 0, 1042, 1035, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, - 1042, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 130, 1, 0, 0, 0, 1046, - 1047, 5, 36, 0, 0, 1047, 1048, 5, 91, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, - 1050, 3, 123, 61, 0, 1050, 1051, 5, 93, 0, 0, 1051, 132, 1, 0, 0, 0, 1052, - 1053, 5, 117, 0, 0, 1053, 1056, 5, 56, 0, 0, 1054, 1056, 7, 0, 0, 0, 1055, - 1052, 1, 0, 0, 0, 1055, 1054, 1, 0, 0, 0, 1056, 134, 1, 0, 0, 0, 1057, - 1059, 3, 139, 69, 0, 1058, 1057, 1, 0, 0, 0, 1059, 1060, 1, 0, 0, 0, 1060, - 1058, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 136, 1, 0, 0, 0, 1062, - 1064, 3, 141, 70, 0, 1063, 1062, 1, 0, 0, 0, 1064, 1065, 1, 0, 0, 0, 1065, - 1063, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 138, 1, 0, 0, 0, 1067, - 1075, 8, 1, 0, 0, 1068, 1075, 3, 181, 90, 0, 1069, 1070, 5, 92, 0, 0, 1070, - 1075, 5, 10, 0, 0, 1071, 1072, 5, 92, 0, 0, 1072, 1073, 5, 13, 0, 0, 1073, - 1075, 5, 10, 0, 0, 1074, 1067, 1, 0, 0, 0, 1074, 1068, 1, 0, 0, 0, 1074, - 1069, 1, 0, 0, 0, 1074, 1071, 1, 0, 0, 0, 1075, 140, 1, 0, 0, 0, 1076, - 1084, 8, 2, 0, 0, 1077, 1084, 3, 181, 90, 0, 1078, 1079, 5, 92, 0, 0, 1079, - 1084, 5, 10, 0, 0, 1080, 1081, 5, 92, 0, 0, 1081, 1082, 5, 13, 0, 0, 1082, - 1084, 5, 10, 0, 0, 1083, 1076, 1, 0, 0, 0, 1083, 1077, 1, 0, 0, 0, 1083, - 1078, 1, 0, 0, 0, 1083, 1080, 1, 0, 0, 0, 1084, 142, 1, 0, 0, 0, 1085, - 1086, 7, 3, 0, 0, 1086, 144, 1, 0, 0, 0, 1087, 1088, 7, 4, 0, 0, 1088, - 146, 1, 0, 0, 0, 1089, 1090, 5, 48, 0, 0, 1090, 1092, 7, 5, 0, 0, 1091, - 1093, 7, 6, 0, 0, 1092, 1091, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, - 1092, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, 1095, 148, 1, 0, 0, 0, 1096, - 1100, 3, 155, 77, 0, 1097, 1099, 3, 145, 72, 0, 1098, 1097, 1, 0, 0, 0, - 1099, 1102, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1100, 1101, 1, 0, 0, 0, - 1101, 1105, 1, 0, 0, 0, 1102, 1100, 1, 0, 0, 0, 1103, 1105, 5, 48, 0, 0, - 1104, 1096, 1, 0, 0, 0, 1104, 1103, 1, 0, 0, 0, 1105, 150, 1, 0, 0, 0, - 1106, 1110, 5, 48, 0, 0, 1107, 1109, 3, 157, 78, 0, 1108, 1107, 1, 0, 0, - 0, 1109, 1112, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1110, 1111, 1, 0, 0, - 0, 1111, 152, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1113, 1114, 5, 48, 0, - 0, 1114, 1115, 7, 7, 0, 0, 1115, 1116, 3, 177, 88, 0, 1116, 154, 1, 0, - 0, 0, 1117, 1118, 7, 8, 0, 0, 1118, 156, 1, 0, 0, 0, 1119, 1120, 7, 9, - 0, 0, 1120, 158, 1, 0, 0, 0, 1121, 1122, 7, 10, 0, 0, 1122, 160, 1, 0, - 0, 0, 1123, 1124, 3, 159, 79, 0, 1124, 1125, 3, 159, 79, 0, 1125, 1126, - 3, 159, 79, 0, 1126, 1127, 3, 159, 79, 0, 1127, 162, 1, 0, 0, 0, 1128, - 1129, 5, 92, 0, 0, 1129, 1130, 5, 117, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, - 1139, 3, 161, 80, 0, 1132, 1133, 5, 92, 0, 0, 1133, 1134, 5, 85, 0, 0, - 1134, 1135, 1, 0, 0, 0, 1135, 1136, 3, 161, 80, 0, 1136, 1137, 3, 161, - 80, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1128, 1, 0, 0, 0, 1138, 1132, 1, 0, - 0, 0, 1139, 164, 1, 0, 0, 0, 1140, 1142, 3, 169, 84, 0, 1141, 1143, 3, - 171, 85, 0, 1142, 1141, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1148, - 1, 0, 0, 0, 1144, 1145, 3, 173, 86, 0, 1145, 1146, 3, 171, 85, 0, 1146, - 1148, 1, 0, 0, 0, 1147, 1140, 1, 0, 0, 0, 1147, 1144, 1, 0, 0, 0, 1148, - 166, 1, 0, 0, 0, 1149, 1150, 5, 48, 0, 0, 1150, 1153, 7, 7, 0, 0, 1151, - 1154, 3, 175, 87, 0, 1152, 1154, 3, 177, 88, 0, 1153, 1151, 1, 0, 0, 0, - 1153, 1152, 1, 0, 0, 0, 1154, 1155, 1, 0, 0, 0, 1155, 1156, 3, 179, 89, - 0, 1156, 168, 1, 0, 0, 0, 1157, 1159, 3, 173, 86, 0, 1158, 1157, 1, 0, - 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1161, 5, 46, - 0, 0, 1161, 1166, 3, 173, 86, 0, 1162, 1163, 3, 173, 86, 0, 1163, 1164, - 5, 46, 0, 0, 1164, 1166, 1, 0, 0, 0, 1165, 1158, 1, 0, 0, 0, 1165, 1162, - 1, 0, 0, 0, 1166, 170, 1, 0, 0, 0, 1167, 1169, 7, 11, 0, 0, 1168, 1170, - 7, 12, 0, 0, 1169, 1168, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1171, - 1, 0, 0, 0, 1171, 1172, 3, 173, 86, 0, 1172, 172, 1, 0, 0, 0, 1173, 1175, - 3, 145, 72, 0, 1174, 1173, 1, 0, 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1174, - 1, 0, 0, 0, 1176, 1177, 1, 0, 0, 0, 1177, 174, 1, 0, 0, 0, 1178, 1180, - 3, 177, 88, 0, 1179, 1178, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1181, - 1, 0, 0, 0, 1181, 1182, 5, 46, 0, 0, 1182, 1187, 3, 177, 88, 0, 1183, 1184, - 3, 177, 88, 0, 1184, 1185, 5, 46, 0, 0, 1185, 1187, 1, 0, 0, 0, 1186, 1179, - 1, 0, 0, 0, 1186, 1183, 1, 0, 0, 0, 1187, 176, 1, 0, 0, 0, 1188, 1190, - 3, 159, 79, 0, 1189, 1188, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1189, - 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 178, 1, 0, 0, 0, 1193, 1195, - 7, 13, 0, 0, 1194, 1196, 7, 12, 0, 0, 1195, 1194, 1, 0, 0, 0, 1195, 1196, - 1, 0, 0, 0, 1196, 1197, 1, 0, 0, 0, 1197, 1198, 3, 173, 86, 0, 1198, 180, - 1, 0, 0, 0, 1199, 1200, 5, 92, 0, 0, 1200, 1215, 7, 14, 0, 0, 1201, 1202, - 5, 92, 0, 0, 1202, 1204, 3, 157, 78, 0, 1203, 1205, 3, 157, 78, 0, 1204, - 1203, 1, 0, 0, 0, 1204, 1205, 1, 0, 0, 0, 1205, 1207, 1, 0, 0, 0, 1206, - 1208, 3, 157, 78, 0, 1207, 1206, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, - 1215, 1, 0, 0, 0, 1209, 1210, 5, 92, 0, 0, 1210, 1211, 5, 120, 0, 0, 1211, - 1212, 1, 0, 0, 0, 1212, 1215, 3, 177, 88, 0, 1213, 1215, 3, 163, 81, 0, - 1214, 1199, 1, 0, 0, 0, 1214, 1201, 1, 0, 0, 0, 1214, 1209, 1, 0, 0, 0, - 1214, 1213, 1, 0, 0, 0, 1215, 182, 1, 0, 0, 0, 1216, 1218, 7, 15, 0, 0, - 1217, 1216, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, - 1219, 1220, 1, 0, 0, 0, 1220, 1221, 1, 0, 0, 0, 1221, 1222, 6, 91, 0, 0, - 1222, 184, 1, 0, 0, 0, 1223, 1225, 5, 13, 0, 0, 1224, 1226, 5, 10, 0, 0, - 1225, 1224, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 1229, 1, 0, 0, 0, - 1227, 1229, 5, 10, 0, 0, 1228, 1223, 1, 0, 0, 0, 1228, 1227, 1, 0, 0, 0, - 1229, 1230, 1, 0, 0, 0, 1230, 1231, 6, 92, 0, 0, 1231, 186, 1, 0, 0, 0, - 73, 0, 225, 239, 261, 287, 315, 333, 341, 383, 420, 428, 444, 468, 479, - 485, 490, 492, 523, 559, 595, 625, 663, 701, 727, 757, 777, 799, 823, 845, - 869, 897, 917, 939, 961, 990, 996, 1000, 1005, 1007, 1017, 1021, 1026, - 1029, 1033, 1038, 1044, 1055, 1060, 1065, 1074, 1083, 1094, 1100, 1104, - 1110, 1138, 1142, 1147, 1153, 1158, 1165, 1169, 1176, 1179, 1186, 1191, - 1195, 1204, 1207, 1214, 1219, 1225, 1228, 1, 6, 0, 0, + 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 0, + 147, 0, 149, 0, 151, 0, 153, 0, 155, 0, 157, 0, 159, 0, 161, 0, 163, 0, + 165, 0, 167, 0, 169, 0, 171, 0, 173, 0, 175, 0, 177, 0, 179, 0, 181, 0, + 183, 0, 185, 0, 187, 0, 189, 0, 191, 0, 193, 0, 195, 73, 197, 74, 1, 0, + 16, 3, 0, 76, 76, 85, 85, 117, 117, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, + 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 3, 0, 65, 90, 95, 95, 97, 122, 1, + 0, 48, 57, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 2, 0, 88, 88, 120, 120, + 1, 0, 49, 57, 1, 0, 48, 55, 3, 0, 48, 57, 65, 70, 97, 102, 2, 0, 69, 69, + 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 80, 80, 112, 112, 10, 0, 34, 34, + 39, 39, 63, 63, 92, 92, 97, 98, 102, 102, 110, 110, 114, 114, 116, 116, + 118, 118, 2, 0, 9, 9, 32, 32, 1441, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, + 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, + 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, + 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, + 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, + 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, + 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, + 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, + 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, + 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, + 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, + 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, + 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, + 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, + 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, + 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, + 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, + 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, + 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, + 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, + 1, 0, 0, 0, 1, 199, 1, 0, 0, 0, 3, 201, 1, 0, 0, 0, 5, 203, 1, 0, 0, 0, + 7, 205, 1, 0, 0, 0, 9, 207, 1, 0, 0, 0, 11, 209, 1, 0, 0, 0, 13, 211, 1, + 0, 0, 0, 15, 213, 1, 0, 0, 0, 17, 215, 1, 0, 0, 0, 19, 218, 1, 0, 0, 0, + 21, 220, 1, 0, 0, 0, 23, 223, 1, 0, 0, 0, 25, 226, 1, 0, 0, 0, 27, 237, + 1, 0, 0, 0, 29, 251, 1, 0, 0, 0, 31, 273, 1, 0, 0, 0, 33, 299, 1, 0, 0, + 0, 35, 327, 1, 0, 0, 0, 37, 347, 1, 0, 0, 0, 39, 367, 1, 0, 0, 0, 41, 391, + 1, 0, 0, 0, 43, 413, 1, 0, 0, 0, 45, 437, 1, 0, 0, 0, 47, 455, 1, 0, 0, + 0, 49, 463, 1, 0, 0, 0, 51, 505, 1, 0, 0, 0, 53, 525, 1, 0, 0, 0, 55, 527, + 1, 0, 0, 0, 57, 529, 1, 0, 0, 0, 59, 531, 1, 0, 0, 0, 61, 533, 1, 0, 0, + 0, 63, 535, 1, 0, 0, 0, 65, 537, 1, 0, 0, 0, 67, 539, 1, 0, 0, 0, 69, 542, + 1, 0, 0, 0, 71, 545, 1, 0, 0, 0, 73, 548, 1, 0, 0, 0, 75, 550, 1, 0, 0, + 0, 77, 552, 1, 0, 0, 0, 79, 562, 1, 0, 0, 0, 81, 570, 1, 0, 0, 0, 83, 586, + 1, 0, 0, 0, 85, 610, 1, 0, 0, 0, 87, 612, 1, 0, 0, 0, 89, 621, 1, 0, 0, + 0, 91, 627, 1, 0, 0, 0, 93, 629, 1, 0, 0, 0, 95, 665, 1, 0, 0, 0, 97, 701, + 1, 0, 0, 0, 99, 737, 1, 0, 0, 0, 101, 767, 1, 0, 0, 0, 103, 805, 1, 0, + 0, 0, 105, 843, 1, 0, 0, 0, 107, 869, 1, 0, 0, 0, 109, 899, 1, 0, 0, 0, + 111, 919, 1, 0, 0, 0, 113, 941, 1, 0, 0, 0, 115, 965, 1, 0, 0, 0, 117, + 987, 1, 0, 0, 0, 119, 1011, 1, 0, 0, 0, 121, 1039, 1, 0, 0, 0, 123, 1059, + 1, 0, 0, 0, 125, 1081, 1, 0, 0, 0, 127, 1103, 1, 0, 0, 0, 129, 1132, 1, + 0, 0, 0, 131, 1138, 1, 0, 0, 0, 133, 1142, 1, 0, 0, 0, 135, 1144, 1, 0, + 0, 0, 137, 1152, 1, 0, 0, 0, 139, 1159, 1, 0, 0, 0, 141, 1175, 1, 0, 0, + 0, 143, 1188, 1, 0, 0, 0, 145, 1197, 1, 0, 0, 0, 147, 1200, 1, 0, 0, 0, + 149, 1205, 1, 0, 0, 0, 151, 1216, 1, 0, 0, 0, 153, 1225, 1, 0, 0, 0, 155, + 1227, 1, 0, 0, 0, 157, 1229, 1, 0, 0, 0, 159, 1231, 1, 0, 0, 0, 161, 1246, + 1, 0, 0, 0, 163, 1248, 1, 0, 0, 0, 165, 1255, 1, 0, 0, 0, 167, 1259, 1, + 0, 0, 0, 169, 1261, 1, 0, 0, 0, 171, 1263, 1, 0, 0, 0, 173, 1265, 1, 0, + 0, 0, 175, 1280, 1, 0, 0, 0, 177, 1289, 1, 0, 0, 0, 179, 1291, 1, 0, 0, + 0, 181, 1307, 1, 0, 0, 0, 183, 1309, 1, 0, 0, 0, 185, 1316, 1, 0, 0, 0, + 187, 1328, 1, 0, 0, 0, 189, 1331, 1, 0, 0, 0, 191, 1335, 1, 0, 0, 0, 193, + 1356, 1, 0, 0, 0, 195, 1359, 1, 0, 0, 0, 197, 1370, 1, 0, 0, 0, 199, 200, + 5, 40, 0, 0, 200, 2, 1, 0, 0, 0, 201, 202, 5, 41, 0, 0, 202, 4, 1, 0, 0, + 0, 203, 204, 5, 91, 0, 0, 204, 6, 1, 0, 0, 0, 205, 206, 5, 44, 0, 0, 206, + 8, 1, 0, 0, 0, 207, 208, 5, 93, 0, 0, 208, 10, 1, 0, 0, 0, 209, 210, 5, + 123, 0, 0, 210, 12, 1, 0, 0, 0, 211, 212, 5, 125, 0, 0, 212, 14, 1, 0, + 0, 0, 213, 214, 5, 60, 0, 0, 214, 16, 1, 0, 0, 0, 215, 216, 5, 60, 0, 0, + 216, 217, 5, 61, 0, 0, 217, 18, 1, 0, 0, 0, 218, 219, 5, 62, 0, 0, 219, + 20, 1, 0, 0, 0, 220, 221, 5, 62, 0, 0, 221, 222, 5, 61, 0, 0, 222, 22, + 1, 0, 0, 0, 223, 224, 5, 61, 0, 0, 224, 225, 5, 61, 0, 0, 225, 24, 1, 0, + 0, 0, 226, 227, 5, 33, 0, 0, 227, 228, 5, 61, 0, 0, 228, 26, 1, 0, 0, 0, + 229, 230, 5, 108, 0, 0, 230, 231, 5, 105, 0, 0, 231, 232, 5, 107, 0, 0, + 232, 238, 5, 101, 0, 0, 233, 234, 5, 76, 0, 0, 234, 235, 5, 73, 0, 0, 235, + 236, 5, 75, 0, 0, 236, 238, 5, 69, 0, 0, 237, 229, 1, 0, 0, 0, 237, 233, + 1, 0, 0, 0, 238, 28, 1, 0, 0, 0, 239, 240, 5, 101, 0, 0, 240, 241, 5, 120, + 0, 0, 241, 242, 5, 105, 0, 0, 242, 243, 5, 115, 0, 0, 243, 244, 5, 116, + 0, 0, 244, 252, 5, 115, 0, 0, 245, 246, 5, 69, 0, 0, 246, 247, 5, 88, 0, + 0, 247, 248, 5, 73, 0, 0, 248, 249, 5, 83, 0, 0, 249, 250, 5, 84, 0, 0, + 250, 252, 5, 83, 0, 0, 251, 239, 1, 0, 0, 0, 251, 245, 1, 0, 0, 0, 252, + 30, 1, 0, 0, 0, 253, 254, 5, 116, 0, 0, 254, 255, 5, 101, 0, 0, 255, 256, + 5, 120, 0, 0, 256, 257, 5, 116, 0, 0, 257, 258, 5, 95, 0, 0, 258, 259, + 5, 109, 0, 0, 259, 260, 5, 97, 0, 0, 260, 261, 5, 116, 0, 0, 261, 262, + 5, 99, 0, 0, 262, 274, 5, 104, 0, 0, 263, 264, 5, 84, 0, 0, 264, 265, 5, + 69, 0, 0, 265, 266, 5, 88, 0, 0, 266, 267, 5, 84, 0, 0, 267, 268, 5, 95, + 0, 0, 268, 269, 5, 77, 0, 0, 269, 270, 5, 65, 0, 0, 270, 271, 5, 84, 0, + 0, 271, 272, 5, 67, 0, 0, 272, 274, 5, 72, 0, 0, 273, 253, 1, 0, 0, 0, + 273, 263, 1, 0, 0, 0, 274, 32, 1, 0, 0, 0, 275, 276, 5, 112, 0, 0, 276, + 277, 5, 104, 0, 0, 277, 278, 5, 114, 0, 0, 278, 279, 5, 97, 0, 0, 279, + 280, 5, 115, 0, 0, 280, 281, 5, 101, 0, 0, 281, 282, 5, 95, 0, 0, 282, + 283, 5, 109, 0, 0, 283, 284, 5, 97, 0, 0, 284, 285, 5, 116, 0, 0, 285, + 286, 5, 99, 0, 0, 286, 300, 5, 104, 0, 0, 287, 288, 5, 80, 0, 0, 288, 289, + 5, 72, 0, 0, 289, 290, 5, 82, 0, 0, 290, 291, 5, 65, 0, 0, 291, 292, 5, + 83, 0, 0, 292, 293, 5, 69, 0, 0, 293, 294, 5, 95, 0, 0, 294, 295, 5, 77, + 0, 0, 295, 296, 5, 65, 0, 0, 296, 297, 5, 84, 0, 0, 297, 298, 5, 67, 0, + 0, 298, 300, 5, 72, 0, 0, 299, 275, 1, 0, 0, 0, 299, 287, 1, 0, 0, 0, 300, + 34, 1, 0, 0, 0, 301, 302, 5, 114, 0, 0, 302, 303, 5, 97, 0, 0, 303, 304, + 5, 110, 0, 0, 304, 305, 5, 100, 0, 0, 305, 306, 5, 111, 0, 0, 306, 307, + 5, 109, 0, 0, 307, 308, 5, 95, 0, 0, 308, 309, 5, 115, 0, 0, 309, 310, + 5, 97, 0, 0, 310, 311, 5, 109, 0, 0, 311, 312, 5, 112, 0, 0, 312, 313, + 5, 108, 0, 0, 313, 328, 5, 101, 0, 0, 314, 315, 5, 82, 0, 0, 315, 316, + 5, 65, 0, 0, 316, 317, 5, 78, 0, 0, 317, 318, 5, 68, 0, 0, 318, 319, 5, + 79, 0, 0, 319, 320, 5, 77, 0, 0, 320, 321, 5, 95, 0, 0, 321, 322, 5, 83, + 0, 0, 322, 323, 5, 65, 0, 0, 323, 324, 5, 77, 0, 0, 324, 325, 5, 80, 0, + 0, 325, 326, 5, 76, 0, 0, 326, 328, 5, 69, 0, 0, 327, 301, 1, 0, 0, 0, + 327, 314, 1, 0, 0, 0, 328, 36, 1, 0, 0, 0, 329, 330, 5, 109, 0, 0, 330, + 331, 5, 97, 0, 0, 331, 332, 5, 116, 0, 0, 332, 333, 5, 99, 0, 0, 333, 334, + 5, 104, 0, 0, 334, 335, 5, 95, 0, 0, 335, 336, 5, 97, 0, 0, 336, 337, 5, + 108, 0, 0, 337, 348, 5, 108, 0, 0, 338, 339, 5, 77, 0, 0, 339, 340, 5, + 65, 0, 0, 340, 341, 5, 84, 0, 0, 341, 342, 5, 67, 0, 0, 342, 343, 5, 72, + 0, 0, 343, 344, 5, 95, 0, 0, 344, 345, 5, 65, 0, 0, 345, 346, 5, 76, 0, + 0, 346, 348, 5, 76, 0, 0, 347, 329, 1, 0, 0, 0, 347, 338, 1, 0, 0, 0, 348, + 38, 1, 0, 0, 0, 349, 350, 5, 109, 0, 0, 350, 351, 5, 97, 0, 0, 351, 352, + 5, 116, 0, 0, 352, 353, 5, 99, 0, 0, 353, 354, 5, 104, 0, 0, 354, 355, + 5, 95, 0, 0, 355, 356, 5, 97, 0, 0, 356, 357, 5, 110, 0, 0, 357, 368, 5, + 121, 0, 0, 358, 359, 5, 77, 0, 0, 359, 360, 5, 65, 0, 0, 360, 361, 5, 84, + 0, 0, 361, 362, 5, 67, 0, 0, 362, 363, 5, 72, 0, 0, 363, 364, 5, 95, 0, + 0, 364, 365, 5, 65, 0, 0, 365, 366, 5, 78, 0, 0, 366, 368, 5, 89, 0, 0, + 367, 349, 1, 0, 0, 0, 367, 358, 1, 0, 0, 0, 368, 40, 1, 0, 0, 0, 369, 370, + 5, 109, 0, 0, 370, 371, 5, 97, 0, 0, 371, 372, 5, 116, 0, 0, 372, 373, + 5, 99, 0, 0, 373, 374, 5, 104, 0, 0, 374, 375, 5, 95, 0, 0, 375, 376, 5, + 108, 0, 0, 376, 377, 5, 101, 0, 0, 377, 378, 5, 97, 0, 0, 378, 379, 5, + 115, 0, 0, 379, 392, 5, 116, 0, 0, 380, 381, 5, 77, 0, 0, 381, 382, 5, + 65, 0, 0, 382, 383, 5, 84, 0, 0, 383, 384, 5, 67, 0, 0, 384, 385, 5, 72, + 0, 0, 385, 386, 5, 95, 0, 0, 386, 387, 5, 76, 0, 0, 387, 388, 5, 69, 0, + 0, 388, 389, 5, 65, 0, 0, 389, 390, 5, 83, 0, 0, 390, 392, 5, 84, 0, 0, + 391, 369, 1, 0, 0, 0, 391, 380, 1, 0, 0, 0, 392, 42, 1, 0, 0, 0, 393, 394, + 5, 109, 0, 0, 394, 395, 5, 97, 0, 0, 395, 396, 5, 116, 0, 0, 396, 397, + 5, 99, 0, 0, 397, 398, 5, 104, 0, 0, 398, 399, 5, 95, 0, 0, 399, 400, 5, + 109, 0, 0, 400, 401, 5, 111, 0, 0, 401, 402, 5, 115, 0, 0, 402, 414, 5, + 116, 0, 0, 403, 404, 5, 77, 0, 0, 404, 405, 5, 65, 0, 0, 405, 406, 5, 84, + 0, 0, 406, 407, 5, 67, 0, 0, 407, 408, 5, 72, 0, 0, 408, 409, 5, 95, 0, + 0, 409, 410, 5, 77, 0, 0, 410, 411, 5, 79, 0, 0, 411, 412, 5, 83, 0, 0, + 412, 414, 5, 84, 0, 0, 413, 393, 1, 0, 0, 0, 413, 403, 1, 0, 0, 0, 414, + 44, 1, 0, 0, 0, 415, 416, 5, 109, 0, 0, 416, 417, 5, 97, 0, 0, 417, 418, + 5, 116, 0, 0, 418, 419, 5, 99, 0, 0, 419, 420, 5, 104, 0, 0, 420, 421, + 5, 95, 0, 0, 421, 422, 5, 101, 0, 0, 422, 423, 5, 120, 0, 0, 423, 424, + 5, 97, 0, 0, 424, 425, 5, 99, 0, 0, 425, 438, 5, 116, 0, 0, 426, 427, 5, + 77, 0, 0, 427, 428, 5, 65, 0, 0, 428, 429, 5, 84, 0, 0, 429, 430, 5, 67, + 0, 0, 430, 431, 5, 72, 0, 0, 431, 432, 5, 95, 0, 0, 432, 433, 5, 69, 0, + 0, 433, 434, 5, 88, 0, 0, 434, 435, 5, 65, 0, 0, 435, 436, 5, 67, 0, 0, + 436, 438, 5, 84, 0, 0, 437, 415, 1, 0, 0, 0, 437, 426, 1, 0, 0, 0, 438, + 46, 1, 0, 0, 0, 439, 440, 5, 105, 0, 0, 440, 441, 5, 110, 0, 0, 441, 442, + 5, 116, 0, 0, 442, 443, 5, 101, 0, 0, 443, 444, 5, 114, 0, 0, 444, 445, + 5, 118, 0, 0, 445, 446, 5, 97, 0, 0, 446, 456, 5, 108, 0, 0, 447, 448, + 5, 73, 0, 0, 448, 449, 5, 78, 0, 0, 449, 450, 5, 84, 0, 0, 450, 451, 5, + 69, 0, 0, 451, 452, 5, 82, 0, 0, 452, 453, 5, 86, 0, 0, 453, 454, 5, 65, + 0, 0, 454, 456, 5, 76, 0, 0, 455, 439, 1, 0, 0, 0, 455, 447, 1, 0, 0, 0, + 456, 48, 1, 0, 0, 0, 457, 458, 5, 105, 0, 0, 458, 459, 5, 115, 0, 0, 459, + 464, 5, 111, 0, 0, 460, 461, 5, 73, 0, 0, 461, 462, 5, 83, 0, 0, 462, 464, + 5, 79, 0, 0, 463, 457, 1, 0, 0, 0, 463, 460, 1, 0, 0, 0, 464, 50, 1, 0, + 0, 0, 465, 466, 5, 109, 0, 0, 466, 467, 5, 105, 0, 0, 467, 468, 5, 110, + 0, 0, 468, 469, 5, 105, 0, 0, 469, 470, 5, 109, 0, 0, 470, 471, 5, 117, + 0, 0, 471, 472, 5, 109, 0, 0, 472, 473, 5, 95, 0, 0, 473, 474, 5, 115, + 0, 0, 474, 475, 5, 104, 0, 0, 475, 476, 5, 111, 0, 0, 476, 477, 5, 117, + 0, 0, 477, 478, 5, 108, 0, 0, 478, 479, 5, 100, 0, 0, 479, 480, 5, 95, + 0, 0, 480, 481, 5, 109, 0, 0, 481, 482, 5, 97, 0, 0, 482, 483, 5, 116, + 0, 0, 483, 484, 5, 99, 0, 0, 484, 506, 5, 104, 0, 0, 485, 486, 5, 77, 0, + 0, 486, 487, 5, 73, 0, 0, 487, 488, 5, 78, 0, 0, 488, 489, 5, 73, 0, 0, + 489, 490, 5, 77, 0, 0, 490, 491, 5, 85, 0, 0, 491, 492, 5, 77, 0, 0, 492, + 493, 5, 95, 0, 0, 493, 494, 5, 83, 0, 0, 494, 495, 5, 72, 0, 0, 495, 496, + 5, 79, 0, 0, 496, 497, 5, 85, 0, 0, 497, 498, 5, 76, 0, 0, 498, 499, 5, + 68, 0, 0, 499, 500, 5, 95, 0, 0, 500, 501, 5, 77, 0, 0, 501, 502, 5, 65, + 0, 0, 502, 503, 5, 84, 0, 0, 503, 504, 5, 67, 0, 0, 504, 506, 5, 72, 0, + 0, 505, 465, 1, 0, 0, 0, 505, 485, 1, 0, 0, 0, 506, 52, 1, 0, 0, 0, 507, + 508, 5, 116, 0, 0, 508, 509, 5, 104, 0, 0, 509, 510, 5, 114, 0, 0, 510, + 511, 5, 101, 0, 0, 511, 512, 5, 115, 0, 0, 512, 513, 5, 104, 0, 0, 513, + 514, 5, 111, 0, 0, 514, 515, 5, 108, 0, 0, 515, 526, 5, 100, 0, 0, 516, + 517, 5, 84, 0, 0, 517, 518, 5, 72, 0, 0, 518, 519, 5, 82, 0, 0, 519, 520, + 5, 69, 0, 0, 520, 521, 5, 83, 0, 0, 521, 522, 5, 72, 0, 0, 522, 523, 5, + 79, 0, 0, 523, 524, 5, 76, 0, 0, 524, 526, 5, 68, 0, 0, 525, 507, 1, 0, + 0, 0, 525, 516, 1, 0, 0, 0, 526, 54, 1, 0, 0, 0, 527, 528, 5, 61, 0, 0, + 528, 56, 1, 0, 0, 0, 529, 530, 5, 43, 0, 0, 530, 58, 1, 0, 0, 0, 531, 532, + 5, 45, 0, 0, 532, 60, 1, 0, 0, 0, 533, 534, 5, 42, 0, 0, 534, 62, 1, 0, + 0, 0, 535, 536, 5, 47, 0, 0, 536, 64, 1, 0, 0, 0, 537, 538, 5, 37, 0, 0, + 538, 66, 1, 0, 0, 0, 539, 540, 5, 42, 0, 0, 540, 541, 5, 42, 0, 0, 541, + 68, 1, 0, 0, 0, 542, 543, 5, 60, 0, 0, 543, 544, 5, 60, 0, 0, 544, 70, + 1, 0, 0, 0, 545, 546, 5, 62, 0, 0, 546, 547, 5, 62, 0, 0, 547, 72, 1, 0, + 0, 0, 548, 549, 5, 38, 0, 0, 549, 74, 1, 0, 0, 0, 550, 551, 5, 124, 0, + 0, 551, 76, 1, 0, 0, 0, 552, 553, 5, 94, 0, 0, 553, 78, 1, 0, 0, 0, 554, + 555, 5, 38, 0, 0, 555, 563, 5, 38, 0, 0, 556, 557, 5, 97, 0, 0, 557, 558, + 5, 110, 0, 0, 558, 563, 5, 100, 0, 0, 559, 560, 5, 65, 0, 0, 560, 561, + 5, 78, 0, 0, 561, 563, 5, 68, 0, 0, 562, 554, 1, 0, 0, 0, 562, 556, 1, + 0, 0, 0, 562, 559, 1, 0, 0, 0, 563, 80, 1, 0, 0, 0, 564, 565, 5, 124, 0, + 0, 565, 571, 5, 124, 0, 0, 566, 567, 5, 111, 0, 0, 567, 571, 5, 114, 0, + 0, 568, 569, 5, 79, 0, 0, 569, 571, 5, 82, 0, 0, 570, 564, 1, 0, 0, 0, + 570, 566, 1, 0, 0, 0, 570, 568, 1, 0, 0, 0, 571, 82, 1, 0, 0, 0, 572, 573, + 5, 105, 0, 0, 573, 574, 5, 115, 0, 0, 574, 575, 5, 32, 0, 0, 575, 576, + 5, 110, 0, 0, 576, 577, 5, 117, 0, 0, 577, 578, 5, 108, 0, 0, 578, 587, + 5, 108, 0, 0, 579, 580, 5, 73, 0, 0, 580, 581, 5, 83, 0, 0, 581, 582, 5, + 32, 0, 0, 582, 583, 5, 78, 0, 0, 583, 584, 5, 85, 0, 0, 584, 585, 5, 76, + 0, 0, 585, 587, 5, 76, 0, 0, 586, 572, 1, 0, 0, 0, 586, 579, 1, 0, 0, 0, + 587, 84, 1, 0, 0, 0, 588, 589, 5, 105, 0, 0, 589, 590, 5, 115, 0, 0, 590, + 591, 5, 32, 0, 0, 591, 592, 5, 110, 0, 0, 592, 593, 5, 111, 0, 0, 593, + 594, 5, 116, 0, 0, 594, 595, 5, 32, 0, 0, 595, 596, 5, 110, 0, 0, 596, + 597, 5, 117, 0, 0, 597, 598, 5, 108, 0, 0, 598, 611, 5, 108, 0, 0, 599, + 600, 5, 73, 0, 0, 600, 601, 5, 83, 0, 0, 601, 602, 5, 32, 0, 0, 602, 603, + 5, 78, 0, 0, 603, 604, 5, 79, 0, 0, 604, 605, 5, 84, 0, 0, 605, 606, 5, + 32, 0, 0, 606, 607, 5, 78, 0, 0, 607, 608, 5, 85, 0, 0, 608, 609, 5, 76, + 0, 0, 609, 611, 5, 76, 0, 0, 610, 588, 1, 0, 0, 0, 610, 599, 1, 0, 0, 0, + 611, 86, 1, 0, 0, 0, 612, 613, 5, 126, 0, 0, 613, 88, 1, 0, 0, 0, 614, + 622, 5, 33, 0, 0, 615, 616, 5, 110, 0, 0, 616, 617, 5, 111, 0, 0, 617, + 622, 5, 116, 0, 0, 618, 619, 5, 78, 0, 0, 619, 620, 5, 79, 0, 0, 620, 622, + 5, 84, 0, 0, 621, 614, 1, 0, 0, 0, 621, 615, 1, 0, 0, 0, 621, 618, 1, 0, + 0, 0, 622, 90, 1, 0, 0, 0, 623, 624, 5, 105, 0, 0, 624, 628, 5, 110, 0, + 0, 625, 626, 5, 73, 0, 0, 626, 628, 5, 78, 0, 0, 627, 623, 1, 0, 0, 0, + 627, 625, 1, 0, 0, 0, 628, 92, 1, 0, 0, 0, 629, 634, 5, 91, 0, 0, 630, + 633, 3, 195, 97, 0, 631, 633, 3, 197, 98, 0, 632, 630, 1, 0, 0, 0, 632, + 631, 1, 0, 0, 0, 633, 636, 1, 0, 0, 0, 634, 632, 1, 0, 0, 0, 634, 635, + 1, 0, 0, 0, 635, 637, 1, 0, 0, 0, 636, 634, 1, 0, 0, 0, 637, 638, 5, 93, + 0, 0, 638, 94, 1, 0, 0, 0, 639, 640, 5, 106, 0, 0, 640, 641, 5, 115, 0, + 0, 641, 642, 5, 111, 0, 0, 642, 643, 5, 110, 0, 0, 643, 644, 5, 95, 0, + 0, 644, 645, 5, 99, 0, 0, 645, 646, 5, 111, 0, 0, 646, 647, 5, 110, 0, + 0, 647, 648, 5, 116, 0, 0, 648, 649, 5, 97, 0, 0, 649, 650, 5, 105, 0, + 0, 650, 651, 5, 110, 0, 0, 651, 666, 5, 115, 0, 0, 652, 653, 5, 74, 0, + 0, 653, 654, 5, 83, 0, 0, 654, 655, 5, 79, 0, 0, 655, 656, 5, 78, 0, 0, + 656, 657, 5, 95, 0, 0, 657, 658, 5, 67, 0, 0, 658, 659, 5, 79, 0, 0, 659, + 660, 5, 78, 0, 0, 660, 661, 5, 84, 0, 0, 661, 662, 5, 65, 0, 0, 662, 663, + 5, 73, 0, 0, 663, 664, 5, 78, 0, 0, 664, 666, 5, 83, 0, 0, 665, 639, 1, + 0, 0, 0, 665, 652, 1, 0, 0, 0, 666, 96, 1, 0, 0, 0, 667, 668, 5, 106, 0, + 0, 668, 669, 5, 115, 0, 0, 669, 670, 5, 111, 0, 0, 670, 671, 5, 110, 0, + 0, 671, 672, 5, 95, 0, 0, 672, 673, 5, 99, 0, 0, 673, 674, 5, 111, 0, 0, + 674, 675, 5, 110, 0, 0, 675, 676, 5, 116, 0, 0, 676, 677, 5, 97, 0, 0, + 677, 678, 5, 105, 0, 0, 678, 679, 5, 110, 0, 0, 679, 680, 5, 115, 0, 0, + 680, 681, 5, 95, 0, 0, 681, 682, 5, 97, 0, 0, 682, 683, 5, 108, 0, 0, 683, + 702, 5, 108, 0, 0, 684, 685, 5, 74, 0, 0, 685, 686, 5, 83, 0, 0, 686, 687, + 5, 79, 0, 0, 687, 688, 5, 78, 0, 0, 688, 689, 5, 95, 0, 0, 689, 690, 5, + 67, 0, 0, 690, 691, 5, 79, 0, 0, 691, 692, 5, 78, 0, 0, 692, 693, 5, 84, + 0, 0, 693, 694, 5, 65, 0, 0, 694, 695, 5, 73, 0, 0, 695, 696, 5, 78, 0, + 0, 696, 697, 5, 83, 0, 0, 697, 698, 5, 95, 0, 0, 698, 699, 5, 65, 0, 0, + 699, 700, 5, 76, 0, 0, 700, 702, 5, 76, 0, 0, 701, 667, 1, 0, 0, 0, 701, + 684, 1, 0, 0, 0, 702, 98, 1, 0, 0, 0, 703, 704, 5, 106, 0, 0, 704, 705, + 5, 115, 0, 0, 705, 706, 5, 111, 0, 0, 706, 707, 5, 110, 0, 0, 707, 708, + 5, 95, 0, 0, 708, 709, 5, 99, 0, 0, 709, 710, 5, 111, 0, 0, 710, 711, 5, + 110, 0, 0, 711, 712, 5, 116, 0, 0, 712, 713, 5, 97, 0, 0, 713, 714, 5, + 105, 0, 0, 714, 715, 5, 110, 0, 0, 715, 716, 5, 115, 0, 0, 716, 717, 5, + 95, 0, 0, 717, 718, 5, 97, 0, 0, 718, 719, 5, 110, 0, 0, 719, 738, 5, 121, + 0, 0, 720, 721, 5, 74, 0, 0, 721, 722, 5, 83, 0, 0, 722, 723, 5, 79, 0, + 0, 723, 724, 5, 78, 0, 0, 724, 725, 5, 95, 0, 0, 725, 726, 5, 67, 0, 0, + 726, 727, 5, 79, 0, 0, 727, 728, 5, 78, 0, 0, 728, 729, 5, 84, 0, 0, 729, + 730, 5, 65, 0, 0, 730, 731, 5, 73, 0, 0, 731, 732, 5, 78, 0, 0, 732, 733, + 5, 83, 0, 0, 733, 734, 5, 95, 0, 0, 734, 735, 5, 65, 0, 0, 735, 736, 5, + 78, 0, 0, 736, 738, 5, 89, 0, 0, 737, 703, 1, 0, 0, 0, 737, 720, 1, 0, + 0, 0, 738, 100, 1, 0, 0, 0, 739, 740, 5, 97, 0, 0, 740, 741, 5, 114, 0, + 0, 741, 742, 5, 114, 0, 0, 742, 743, 5, 97, 0, 0, 743, 744, 5, 121, 0, + 0, 744, 745, 5, 95, 0, 0, 745, 746, 5, 99, 0, 0, 746, 747, 5, 111, 0, 0, + 747, 748, 5, 110, 0, 0, 748, 749, 5, 116, 0, 0, 749, 750, 5, 97, 0, 0, + 750, 751, 5, 105, 0, 0, 751, 752, 5, 110, 0, 0, 752, 768, 5, 115, 0, 0, + 753, 754, 5, 65, 0, 0, 754, 755, 5, 82, 0, 0, 755, 756, 5, 82, 0, 0, 756, + 757, 5, 65, 0, 0, 757, 758, 5, 89, 0, 0, 758, 759, 5, 95, 0, 0, 759, 760, + 5, 67, 0, 0, 760, 761, 5, 79, 0, 0, 761, 762, 5, 78, 0, 0, 762, 763, 5, + 84, 0, 0, 763, 764, 5, 65, 0, 0, 764, 765, 5, 73, 0, 0, 765, 766, 5, 78, + 0, 0, 766, 768, 5, 83, 0, 0, 767, 739, 1, 0, 0, 0, 767, 753, 1, 0, 0, 0, + 768, 102, 1, 0, 0, 0, 769, 770, 5, 97, 0, 0, 770, 771, 5, 114, 0, 0, 771, + 772, 5, 114, 0, 0, 772, 773, 5, 97, 0, 0, 773, 774, 5, 121, 0, 0, 774, + 775, 5, 95, 0, 0, 775, 776, 5, 99, 0, 0, 776, 777, 5, 111, 0, 0, 777, 778, + 5, 110, 0, 0, 778, 779, 5, 116, 0, 0, 779, 780, 5, 97, 0, 0, 780, 781, + 5, 105, 0, 0, 781, 782, 5, 110, 0, 0, 782, 783, 5, 115, 0, 0, 783, 784, + 5, 95, 0, 0, 784, 785, 5, 97, 0, 0, 785, 786, 5, 108, 0, 0, 786, 806, 5, + 108, 0, 0, 787, 788, 5, 65, 0, 0, 788, 789, 5, 82, 0, 0, 789, 790, 5, 82, + 0, 0, 790, 791, 5, 65, 0, 0, 791, 792, 5, 89, 0, 0, 792, 793, 5, 95, 0, + 0, 793, 794, 5, 67, 0, 0, 794, 795, 5, 79, 0, 0, 795, 796, 5, 78, 0, 0, + 796, 797, 5, 84, 0, 0, 797, 798, 5, 65, 0, 0, 798, 799, 5, 73, 0, 0, 799, + 800, 5, 78, 0, 0, 800, 801, 5, 83, 0, 0, 801, 802, 5, 95, 0, 0, 802, 803, + 5, 65, 0, 0, 803, 804, 5, 76, 0, 0, 804, 806, 5, 76, 0, 0, 805, 769, 1, + 0, 0, 0, 805, 787, 1, 0, 0, 0, 806, 104, 1, 0, 0, 0, 807, 808, 5, 97, 0, + 0, 808, 809, 5, 114, 0, 0, 809, 810, 5, 114, 0, 0, 810, 811, 5, 97, 0, + 0, 811, 812, 5, 121, 0, 0, 812, 813, 5, 95, 0, 0, 813, 814, 5, 99, 0, 0, + 814, 815, 5, 111, 0, 0, 815, 816, 5, 110, 0, 0, 816, 817, 5, 116, 0, 0, + 817, 818, 5, 97, 0, 0, 818, 819, 5, 105, 0, 0, 819, 820, 5, 110, 0, 0, + 820, 821, 5, 115, 0, 0, 821, 822, 5, 95, 0, 0, 822, 823, 5, 97, 0, 0, 823, + 824, 5, 110, 0, 0, 824, 844, 5, 121, 0, 0, 825, 826, 5, 65, 0, 0, 826, + 827, 5, 82, 0, 0, 827, 828, 5, 82, 0, 0, 828, 829, 5, 65, 0, 0, 829, 830, + 5, 89, 0, 0, 830, 831, 5, 95, 0, 0, 831, 832, 5, 67, 0, 0, 832, 833, 5, + 79, 0, 0, 833, 834, 5, 78, 0, 0, 834, 835, 5, 84, 0, 0, 835, 836, 5, 65, + 0, 0, 836, 837, 5, 73, 0, 0, 837, 838, 5, 78, 0, 0, 838, 839, 5, 83, 0, + 0, 839, 840, 5, 95, 0, 0, 840, 841, 5, 65, 0, 0, 841, 842, 5, 78, 0, 0, + 842, 844, 5, 89, 0, 0, 843, 807, 1, 0, 0, 0, 843, 825, 1, 0, 0, 0, 844, + 106, 1, 0, 0, 0, 845, 846, 5, 97, 0, 0, 846, 847, 5, 114, 0, 0, 847, 848, + 5, 114, 0, 0, 848, 849, 5, 97, 0, 0, 849, 850, 5, 121, 0, 0, 850, 851, + 5, 95, 0, 0, 851, 852, 5, 108, 0, 0, 852, 853, 5, 101, 0, 0, 853, 854, + 5, 110, 0, 0, 854, 855, 5, 103, 0, 0, 855, 856, 5, 116, 0, 0, 856, 870, + 5, 104, 0, 0, 857, 858, 5, 65, 0, 0, 858, 859, 5, 82, 0, 0, 859, 860, 5, + 82, 0, 0, 860, 861, 5, 65, 0, 0, 861, 862, 5, 89, 0, 0, 862, 863, 5, 95, + 0, 0, 863, 864, 5, 76, 0, 0, 864, 865, 5, 69, 0, 0, 865, 866, 5, 78, 0, + 0, 866, 867, 5, 71, 0, 0, 867, 868, 5, 84, 0, 0, 868, 870, 5, 72, 0, 0, + 869, 845, 1, 0, 0, 0, 869, 857, 1, 0, 0, 0, 870, 108, 1, 0, 0, 0, 871, + 872, 5, 101, 0, 0, 872, 873, 5, 108, 0, 0, 873, 874, 5, 101, 0, 0, 874, + 875, 5, 109, 0, 0, 875, 876, 5, 101, 0, 0, 876, 877, 5, 110, 0, 0, 877, + 878, 5, 116, 0, 0, 878, 879, 5, 95, 0, 0, 879, 880, 5, 102, 0, 0, 880, + 881, 5, 105, 0, 0, 881, 882, 5, 108, 0, 0, 882, 883, 5, 116, 0, 0, 883, + 884, 5, 101, 0, 0, 884, 900, 5, 114, 0, 0, 885, 886, 5, 69, 0, 0, 886, + 887, 5, 76, 0, 0, 887, 888, 5, 69, 0, 0, 888, 889, 5, 77, 0, 0, 889, 890, + 5, 69, 0, 0, 890, 891, 5, 78, 0, 0, 891, 892, 5, 84, 0, 0, 892, 893, 5, + 95, 0, 0, 893, 894, 5, 70, 0, 0, 894, 895, 5, 73, 0, 0, 895, 896, 5, 76, + 0, 0, 896, 897, 5, 84, 0, 0, 897, 898, 5, 69, 0, 0, 898, 900, 5, 82, 0, + 0, 899, 871, 1, 0, 0, 0, 899, 885, 1, 0, 0, 0, 900, 110, 1, 0, 0, 0, 901, + 902, 5, 115, 0, 0, 902, 903, 5, 116, 0, 0, 903, 904, 5, 95, 0, 0, 904, + 905, 5, 101, 0, 0, 905, 906, 5, 113, 0, 0, 906, 907, 5, 117, 0, 0, 907, + 908, 5, 97, 0, 0, 908, 909, 5, 108, 0, 0, 909, 920, 5, 115, 0, 0, 910, + 911, 5, 83, 0, 0, 911, 912, 5, 84, 0, 0, 912, 913, 5, 95, 0, 0, 913, 914, + 5, 69, 0, 0, 914, 915, 5, 81, 0, 0, 915, 916, 5, 85, 0, 0, 916, 917, 5, + 65, 0, 0, 917, 918, 5, 76, 0, 0, 918, 920, 5, 83, 0, 0, 919, 901, 1, 0, + 0, 0, 919, 910, 1, 0, 0, 0, 920, 112, 1, 0, 0, 0, 921, 922, 5, 115, 0, + 0, 922, 923, 5, 116, 0, 0, 923, 924, 5, 95, 0, 0, 924, 925, 5, 116, 0, + 0, 925, 926, 5, 111, 0, 0, 926, 927, 5, 117, 0, 0, 927, 928, 5, 99, 0, + 0, 928, 929, 5, 104, 0, 0, 929, 930, 5, 101, 0, 0, 930, 942, 5, 115, 0, + 0, 931, 932, 5, 83, 0, 0, 932, 933, 5, 84, 0, 0, 933, 934, 5, 95, 0, 0, + 934, 935, 5, 84, 0, 0, 935, 936, 5, 79, 0, 0, 936, 937, 5, 85, 0, 0, 937, + 938, 5, 67, 0, 0, 938, 939, 5, 72, 0, 0, 939, 940, 5, 69, 0, 0, 940, 942, + 5, 83, 0, 0, 941, 921, 1, 0, 0, 0, 941, 931, 1, 0, 0, 0, 942, 114, 1, 0, + 0, 0, 943, 944, 5, 115, 0, 0, 944, 945, 5, 116, 0, 0, 945, 946, 5, 95, + 0, 0, 946, 947, 5, 111, 0, 0, 947, 948, 5, 118, 0, 0, 948, 949, 5, 101, + 0, 0, 949, 950, 5, 114, 0, 0, 950, 951, 5, 108, 0, 0, 951, 952, 5, 97, + 0, 0, 952, 953, 5, 112, 0, 0, 953, 966, 5, 115, 0, 0, 954, 955, 5, 83, + 0, 0, 955, 956, 5, 84, 0, 0, 956, 957, 5, 95, 0, 0, 957, 958, 5, 79, 0, + 0, 958, 959, 5, 86, 0, 0, 959, 960, 5, 69, 0, 0, 960, 961, 5, 82, 0, 0, + 961, 962, 5, 76, 0, 0, 962, 963, 5, 65, 0, 0, 963, 964, 5, 80, 0, 0, 964, + 966, 5, 83, 0, 0, 965, 943, 1, 0, 0, 0, 965, 954, 1, 0, 0, 0, 966, 116, + 1, 0, 0, 0, 967, 968, 5, 115, 0, 0, 968, 969, 5, 116, 0, 0, 969, 970, 5, + 95, 0, 0, 970, 971, 5, 99, 0, 0, 971, 972, 5, 114, 0, 0, 972, 973, 5, 111, + 0, 0, 973, 974, 5, 115, 0, 0, 974, 975, 5, 115, 0, 0, 975, 976, 5, 101, + 0, 0, 976, 988, 5, 115, 0, 0, 977, 978, 5, 83, 0, 0, 978, 979, 5, 84, 0, + 0, 979, 980, 5, 95, 0, 0, 980, 981, 5, 67, 0, 0, 981, 982, 5, 82, 0, 0, + 982, 983, 5, 79, 0, 0, 983, 984, 5, 83, 0, 0, 984, 985, 5, 83, 0, 0, 985, + 986, 5, 69, 0, 0, 986, 988, 5, 83, 0, 0, 987, 967, 1, 0, 0, 0, 987, 977, + 1, 0, 0, 0, 988, 118, 1, 0, 0, 0, 989, 990, 5, 115, 0, 0, 990, 991, 5, + 116, 0, 0, 991, 992, 5, 95, 0, 0, 992, 993, 5, 99, 0, 0, 993, 994, 5, 111, + 0, 0, 994, 995, 5, 110, 0, 0, 995, 996, 5, 116, 0, 0, 996, 997, 5, 97, + 0, 0, 997, 998, 5, 105, 0, 0, 998, 999, 5, 110, 0, 0, 999, 1012, 5, 115, + 0, 0, 1000, 1001, 5, 83, 0, 0, 1001, 1002, 5, 84, 0, 0, 1002, 1003, 5, + 95, 0, 0, 1003, 1004, 5, 67, 0, 0, 1004, 1005, 5, 79, 0, 0, 1005, 1006, + 5, 78, 0, 0, 1006, 1007, 5, 84, 0, 0, 1007, 1008, 5, 65, 0, 0, 1008, 1009, + 5, 73, 0, 0, 1009, 1010, 5, 78, 0, 0, 1010, 1012, 5, 83, 0, 0, 1011, 989, + 1, 0, 0, 0, 1011, 1000, 1, 0, 0, 0, 1012, 120, 1, 0, 0, 0, 1013, 1014, + 5, 115, 0, 0, 1014, 1015, 5, 116, 0, 0, 1015, 1016, 5, 95, 0, 0, 1016, + 1017, 5, 105, 0, 0, 1017, 1018, 5, 110, 0, 0, 1018, 1019, 5, 116, 0, 0, + 1019, 1020, 5, 101, 0, 0, 1020, 1021, 5, 114, 0, 0, 1021, 1022, 5, 115, + 0, 0, 1022, 1023, 5, 101, 0, 0, 1023, 1024, 5, 99, 0, 0, 1024, 1025, 5, + 116, 0, 0, 1025, 1040, 5, 115, 0, 0, 1026, 1027, 5, 83, 0, 0, 1027, 1028, + 5, 84, 0, 0, 1028, 1029, 5, 95, 0, 0, 1029, 1030, 5, 73, 0, 0, 1030, 1031, + 5, 78, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 69, 0, 0, 1033, 1034, + 5, 82, 0, 0, 1034, 1035, 5, 83, 0, 0, 1035, 1036, 5, 69, 0, 0, 1036, 1037, + 5, 67, 0, 0, 1037, 1038, 5, 84, 0, 0, 1038, 1040, 5, 83, 0, 0, 1039, 1013, + 1, 0, 0, 0, 1039, 1026, 1, 0, 0, 0, 1040, 122, 1, 0, 0, 0, 1041, 1042, + 5, 115, 0, 0, 1042, 1043, 5, 116, 0, 0, 1043, 1044, 5, 95, 0, 0, 1044, + 1045, 5, 119, 0, 0, 1045, 1046, 5, 105, 0, 0, 1046, 1047, 5, 116, 0, 0, + 1047, 1048, 5, 104, 0, 0, 1048, 1049, 5, 105, 0, 0, 1049, 1060, 5, 110, + 0, 0, 1050, 1051, 5, 83, 0, 0, 1051, 1052, 5, 84, 0, 0, 1052, 1053, 5, + 95, 0, 0, 1053, 1054, 5, 87, 0, 0, 1054, 1055, 5, 73, 0, 0, 1055, 1056, + 5, 84, 0, 0, 1056, 1057, 5, 72, 0, 0, 1057, 1058, 5, 73, 0, 0, 1058, 1060, + 5, 78, 0, 0, 1059, 1041, 1, 0, 0, 0, 1059, 1050, 1, 0, 0, 0, 1060, 124, + 1, 0, 0, 0, 1061, 1062, 5, 115, 0, 0, 1062, 1063, 5, 116, 0, 0, 1063, 1064, + 5, 95, 0, 0, 1064, 1065, 5, 100, 0, 0, 1065, 1066, 5, 119, 0, 0, 1066, + 1067, 5, 105, 0, 0, 1067, 1068, 5, 116, 0, 0, 1068, 1069, 5, 104, 0, 0, + 1069, 1070, 5, 105, 0, 0, 1070, 1082, 5, 110, 0, 0, 1071, 1072, 5, 83, + 0, 0, 1072, 1073, 5, 84, 0, 0, 1073, 1074, 5, 95, 0, 0, 1074, 1075, 5, + 68, 0, 0, 1075, 1076, 5, 87, 0, 0, 1076, 1077, 5, 73, 0, 0, 1077, 1078, + 5, 84, 0, 0, 1078, 1079, 5, 72, 0, 0, 1079, 1080, 5, 73, 0, 0, 1080, 1082, + 5, 78, 0, 0, 1081, 1061, 1, 0, 0, 0, 1081, 1071, 1, 0, 0, 0, 1082, 126, + 1, 0, 0, 0, 1083, 1084, 5, 115, 0, 0, 1084, 1085, 5, 116, 0, 0, 1085, 1086, + 5, 95, 0, 0, 1086, 1087, 5, 105, 0, 0, 1087, 1088, 5, 115, 0, 0, 1088, + 1089, 5, 118, 0, 0, 1089, 1090, 5, 97, 0, 0, 1090, 1091, 5, 108, 0, 0, + 1091, 1092, 5, 105, 0, 0, 1092, 1104, 5, 100, 0, 0, 1093, 1094, 5, 83, + 0, 0, 1094, 1095, 5, 84, 0, 0, 1095, 1096, 5, 95, 0, 0, 1096, 1097, 5, + 73, 0, 0, 1097, 1098, 5, 83, 0, 0, 1098, 1099, 5, 86, 0, 0, 1099, 1100, + 5, 65, 0, 0, 1100, 1101, 5, 76, 0, 0, 1101, 1102, 5, 73, 0, 0, 1102, 1104, + 5, 68, 0, 0, 1103, 1083, 1, 0, 0, 0, 1103, 1093, 1, 0, 0, 0, 1104, 128, + 1, 0, 0, 0, 1105, 1106, 5, 116, 0, 0, 1106, 1107, 5, 114, 0, 0, 1107, 1108, + 5, 117, 0, 0, 1108, 1133, 5, 101, 0, 0, 1109, 1110, 5, 84, 0, 0, 1110, + 1111, 5, 114, 0, 0, 1111, 1112, 5, 117, 0, 0, 1112, 1133, 5, 101, 0, 0, + 1113, 1114, 5, 84, 0, 0, 1114, 1115, 5, 82, 0, 0, 1115, 1116, 5, 85, 0, + 0, 1116, 1133, 5, 69, 0, 0, 1117, 1118, 5, 102, 0, 0, 1118, 1119, 5, 97, + 0, 0, 1119, 1120, 5, 108, 0, 0, 1120, 1121, 5, 115, 0, 0, 1121, 1133, 5, + 101, 0, 0, 1122, 1123, 5, 70, 0, 0, 1123, 1124, 5, 97, 0, 0, 1124, 1125, + 5, 108, 0, 0, 1125, 1126, 5, 115, 0, 0, 1126, 1133, 5, 101, 0, 0, 1127, + 1128, 5, 70, 0, 0, 1128, 1129, 5, 65, 0, 0, 1129, 1130, 5, 76, 0, 0, 1130, + 1131, 5, 83, 0, 0, 1131, 1133, 5, 69, 0, 0, 1132, 1105, 1, 0, 0, 0, 1132, + 1109, 1, 0, 0, 0, 1132, 1113, 1, 0, 0, 0, 1132, 1117, 1, 0, 0, 0, 1132, + 1122, 1, 0, 0, 0, 1132, 1127, 1, 0, 0, 0, 1133, 130, 1, 0, 0, 0, 1134, + 1139, 3, 161, 80, 0, 1135, 1139, 3, 163, 81, 0, 1136, 1139, 3, 165, 82, + 0, 1137, 1139, 3, 159, 79, 0, 1138, 1134, 1, 0, 0, 0, 1138, 1135, 1, 0, + 0, 0, 1138, 1136, 1, 0, 0, 0, 1138, 1137, 1, 0, 0, 0, 1139, 132, 1, 0, + 0, 0, 1140, 1143, 3, 177, 88, 0, 1141, 1143, 3, 179, 89, 0, 1142, 1140, + 1, 0, 0, 0, 1142, 1141, 1, 0, 0, 0, 1143, 134, 1, 0, 0, 0, 1144, 1149, + 3, 155, 77, 0, 1145, 1148, 3, 155, 77, 0, 1146, 1148, 3, 157, 78, 0, 1147, + 1145, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 1151, 1, 0, 0, 0, 1149, + 1147, 1, 0, 0, 0, 1149, 1150, 1, 0, 0, 0, 1150, 136, 1, 0, 0, 0, 1151, + 1149, 1, 0, 0, 0, 1152, 1153, 5, 36, 0, 0, 1153, 1154, 5, 109, 0, 0, 1154, + 1155, 5, 101, 0, 0, 1155, 1156, 5, 116, 0, 0, 1156, 1157, 5, 97, 0, 0, + 1157, 138, 1, 0, 0, 0, 1158, 1160, 3, 145, 72, 0, 1159, 1158, 1, 0, 0, + 0, 1159, 1160, 1, 0, 0, 0, 1160, 1171, 1, 0, 0, 0, 1161, 1163, 5, 34, 0, + 0, 1162, 1164, 3, 147, 73, 0, 1163, 1162, 1, 0, 0, 0, 1163, 1164, 1, 0, + 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1172, 5, 34, 0, 0, 1166, 1168, 5, 39, + 0, 0, 1167, 1169, 3, 149, 74, 0, 1168, 1167, 1, 0, 0, 0, 1168, 1169, 1, + 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1172, 5, 39, 0, 0, 1171, 1161, 1, + 0, 0, 0, 1171, 1166, 1, 0, 0, 0, 1172, 140, 1, 0, 0, 0, 1173, 1176, 3, + 135, 67, 0, 1174, 1176, 3, 137, 68, 0, 1175, 1173, 1, 0, 0, 0, 1175, 1174, + 1, 0, 0, 0, 1176, 1184, 1, 0, 0, 0, 1177, 1180, 5, 91, 0, 0, 1178, 1181, + 3, 139, 69, 0, 1179, 1181, 3, 161, 80, 0, 1180, 1178, 1, 0, 0, 0, 1180, + 1179, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1183, 5, 93, 0, 0, 1183, + 1185, 1, 0, 0, 0, 1184, 1177, 1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, + 1184, 1, 0, 0, 0, 1186, 1187, 1, 0, 0, 0, 1187, 142, 1, 0, 0, 0, 1188, + 1189, 5, 36, 0, 0, 1189, 1190, 5, 91, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, + 1192, 3, 135, 67, 0, 1192, 1193, 5, 93, 0, 0, 1193, 144, 1, 0, 0, 0, 1194, + 1195, 5, 117, 0, 0, 1195, 1198, 5, 56, 0, 0, 1196, 1198, 7, 0, 0, 0, 1197, + 1194, 1, 0, 0, 0, 1197, 1196, 1, 0, 0, 0, 1198, 146, 1, 0, 0, 0, 1199, + 1201, 3, 151, 75, 0, 1200, 1199, 1, 0, 0, 0, 1201, 1202, 1, 0, 0, 0, 1202, + 1200, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 148, 1, 0, 0, 0, 1204, + 1206, 3, 153, 76, 0, 1205, 1204, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, + 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 150, 1, 0, 0, 0, 1209, + 1217, 8, 1, 0, 0, 1210, 1217, 3, 193, 96, 0, 1211, 1212, 5, 92, 0, 0, 1212, + 1217, 5, 10, 0, 0, 1213, 1214, 5, 92, 0, 0, 1214, 1215, 5, 13, 0, 0, 1215, + 1217, 5, 10, 0, 0, 1216, 1209, 1, 0, 0, 0, 1216, 1210, 1, 0, 0, 0, 1216, + 1211, 1, 0, 0, 0, 1216, 1213, 1, 0, 0, 0, 1217, 152, 1, 0, 0, 0, 1218, + 1226, 8, 2, 0, 0, 1219, 1226, 3, 193, 96, 0, 1220, 1221, 5, 92, 0, 0, 1221, + 1226, 5, 10, 0, 0, 1222, 1223, 5, 92, 0, 0, 1223, 1224, 5, 13, 0, 0, 1224, + 1226, 5, 10, 0, 0, 1225, 1218, 1, 0, 0, 0, 1225, 1219, 1, 0, 0, 0, 1225, + 1220, 1, 0, 0, 0, 1225, 1222, 1, 0, 0, 0, 1226, 154, 1, 0, 0, 0, 1227, + 1228, 7, 3, 0, 0, 1228, 156, 1, 0, 0, 0, 1229, 1230, 7, 4, 0, 0, 1230, + 158, 1, 0, 0, 0, 1231, 1232, 5, 48, 0, 0, 1232, 1234, 7, 5, 0, 0, 1233, + 1235, 7, 6, 0, 0, 1234, 1233, 1, 0, 0, 0, 1235, 1236, 1, 0, 0, 0, 1236, + 1234, 1, 0, 0, 0, 1236, 1237, 1, 0, 0, 0, 1237, 160, 1, 0, 0, 0, 1238, + 1242, 3, 167, 83, 0, 1239, 1241, 3, 157, 78, 0, 1240, 1239, 1, 0, 0, 0, + 1241, 1244, 1, 0, 0, 0, 1242, 1240, 1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, + 1243, 1247, 1, 0, 0, 0, 1244, 1242, 1, 0, 0, 0, 1245, 1247, 5, 48, 0, 0, + 1246, 1238, 1, 0, 0, 0, 1246, 1245, 1, 0, 0, 0, 1247, 162, 1, 0, 0, 0, + 1248, 1252, 5, 48, 0, 0, 1249, 1251, 3, 169, 84, 0, 1250, 1249, 1, 0, 0, + 0, 1251, 1254, 1, 0, 0, 0, 1252, 1250, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, + 0, 1253, 164, 1, 0, 0, 0, 1254, 1252, 1, 0, 0, 0, 1255, 1256, 5, 48, 0, + 0, 1256, 1257, 7, 7, 0, 0, 1257, 1258, 3, 189, 94, 0, 1258, 166, 1, 0, + 0, 0, 1259, 1260, 7, 8, 0, 0, 1260, 168, 1, 0, 0, 0, 1261, 1262, 7, 9, + 0, 0, 1262, 170, 1, 0, 0, 0, 1263, 1264, 7, 10, 0, 0, 1264, 172, 1, 0, + 0, 0, 1265, 1266, 3, 171, 85, 0, 1266, 1267, 3, 171, 85, 0, 1267, 1268, + 3, 171, 85, 0, 1268, 1269, 3, 171, 85, 0, 1269, 174, 1, 0, 0, 0, 1270, + 1271, 5, 92, 0, 0, 1271, 1272, 5, 117, 0, 0, 1272, 1273, 1, 0, 0, 0, 1273, + 1281, 3, 173, 86, 0, 1274, 1275, 5, 92, 0, 0, 1275, 1276, 5, 85, 0, 0, + 1276, 1277, 1, 0, 0, 0, 1277, 1278, 3, 173, 86, 0, 1278, 1279, 3, 173, + 86, 0, 1279, 1281, 1, 0, 0, 0, 1280, 1270, 1, 0, 0, 0, 1280, 1274, 1, 0, + 0, 0, 1281, 176, 1, 0, 0, 0, 1282, 1284, 3, 181, 90, 0, 1283, 1285, 3, + 183, 91, 0, 1284, 1283, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1290, + 1, 0, 0, 0, 1286, 1287, 3, 185, 92, 0, 1287, 1288, 3, 183, 91, 0, 1288, + 1290, 1, 0, 0, 0, 1289, 1282, 1, 0, 0, 0, 1289, 1286, 1, 0, 0, 0, 1290, + 178, 1, 0, 0, 0, 1291, 1292, 5, 48, 0, 0, 1292, 1295, 7, 7, 0, 0, 1293, + 1296, 3, 187, 93, 0, 1294, 1296, 3, 189, 94, 0, 1295, 1293, 1, 0, 0, 0, + 1295, 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1298, 3, 191, 95, + 0, 1298, 180, 1, 0, 0, 0, 1299, 1301, 3, 185, 92, 0, 1300, 1299, 1, 0, + 0, 0, 1300, 1301, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, 1303, 5, 46, + 0, 0, 1303, 1308, 3, 185, 92, 0, 1304, 1305, 3, 185, 92, 0, 1305, 1306, + 5, 46, 0, 0, 1306, 1308, 1, 0, 0, 0, 1307, 1300, 1, 0, 0, 0, 1307, 1304, + 1, 0, 0, 0, 1308, 182, 1, 0, 0, 0, 1309, 1311, 7, 11, 0, 0, 1310, 1312, + 7, 12, 0, 0, 1311, 1310, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1313, + 1, 0, 0, 0, 1313, 1314, 3, 185, 92, 0, 1314, 184, 1, 0, 0, 0, 1315, 1317, + 3, 157, 78, 0, 1316, 1315, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 1316, + 1, 0, 0, 0, 1318, 1319, 1, 0, 0, 0, 1319, 186, 1, 0, 0, 0, 1320, 1322, + 3, 189, 94, 0, 1321, 1320, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1323, + 1, 0, 0, 0, 1323, 1324, 5, 46, 0, 0, 1324, 1329, 3, 189, 94, 0, 1325, 1326, + 3, 189, 94, 0, 1326, 1327, 5, 46, 0, 0, 1327, 1329, 1, 0, 0, 0, 1328, 1321, + 1, 0, 0, 0, 1328, 1325, 1, 0, 0, 0, 1329, 188, 1, 0, 0, 0, 1330, 1332, + 3, 171, 85, 0, 1331, 1330, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1331, + 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 190, 1, 0, 0, 0, 1335, 1337, + 7, 13, 0, 0, 1336, 1338, 7, 12, 0, 0, 1337, 1336, 1, 0, 0, 0, 1337, 1338, + 1, 0, 0, 0, 1338, 1339, 1, 0, 0, 0, 1339, 1340, 3, 185, 92, 0, 1340, 192, + 1, 0, 0, 0, 1341, 1342, 5, 92, 0, 0, 1342, 1357, 7, 14, 0, 0, 1343, 1344, + 5, 92, 0, 0, 1344, 1346, 3, 169, 84, 0, 1345, 1347, 3, 169, 84, 0, 1346, + 1345, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1349, 1, 0, 0, 0, 1348, + 1350, 3, 169, 84, 0, 1349, 1348, 1, 0, 0, 0, 1349, 1350, 1, 0, 0, 0, 1350, + 1357, 1, 0, 0, 0, 1351, 1352, 5, 92, 0, 0, 1352, 1353, 5, 120, 0, 0, 1353, + 1354, 1, 0, 0, 0, 1354, 1357, 3, 189, 94, 0, 1355, 1357, 3, 175, 87, 0, + 1356, 1341, 1, 0, 0, 0, 1356, 1343, 1, 0, 0, 0, 1356, 1351, 1, 0, 0, 0, + 1356, 1355, 1, 0, 0, 0, 1357, 194, 1, 0, 0, 0, 1358, 1360, 7, 15, 0, 0, + 1359, 1358, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 1359, 1, 0, 0, 0, + 1361, 1362, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1364, 6, 97, 0, 0, + 1364, 196, 1, 0, 0, 0, 1365, 1367, 5, 13, 0, 0, 1366, 1368, 5, 10, 0, 0, + 1367, 1366, 1, 0, 0, 0, 1367, 1368, 1, 0, 0, 0, 1368, 1371, 1, 0, 0, 0, + 1369, 1371, 5, 10, 0, 0, 1370, 1365, 1, 0, 0, 0, 1370, 1369, 1, 0, 0, 0, + 1371, 1372, 1, 0, 0, 0, 1372, 1373, 6, 98, 0, 0, 1373, 198, 1, 0, 0, 0, + 79, 0, 237, 251, 273, 299, 327, 347, 367, 391, 413, 437, 455, 463, 505, + 525, 562, 570, 586, 610, 621, 627, 632, 634, 665, 701, 737, 767, 805, 843, + 869, 899, 919, 941, 965, 987, 1011, 1039, 1059, 1081, 1103, 1132, 1138, + 1142, 1147, 1149, 1159, 1163, 1168, 1171, 1175, 1180, 1186, 1197, 1202, + 1207, 1216, 1225, 1236, 1242, 1246, 1252, 1280, 1284, 1289, 1295, 1300, + 1307, 1311, 1318, 1321, 1328, 1333, 1337, 1346, 1349, 1356, 1361, 1367, + 1370, 1, 6, 0, 0, } deserializer := antlr.NewATNDeserializer(nil) staticData.atn = deserializer.Deserialize(staticData.serializedATN) @@ -701,54 +772,60 @@ const ( PlanLexerTEXTMATCH = 16 PlanLexerPHRASEMATCH = 17 PlanLexerRANDOMSAMPLE = 18 - PlanLexerINTERVAL = 19 - PlanLexerISO = 20 - PlanLexerMINIMUM_SHOULD_MATCH = 21 - PlanLexerASSIGN = 22 - PlanLexerADD = 23 - PlanLexerSUB = 24 - PlanLexerMUL = 25 - PlanLexerDIV = 26 - PlanLexerMOD = 27 - PlanLexerPOW = 28 - PlanLexerSHL = 29 - PlanLexerSHR = 30 - PlanLexerBAND = 31 - PlanLexerBOR = 32 - PlanLexerBXOR = 33 - PlanLexerAND = 34 - PlanLexerOR = 35 - PlanLexerISNULL = 36 - PlanLexerISNOTNULL = 37 - PlanLexerBNOT = 38 - PlanLexerNOT = 39 - PlanLexerIN = 40 - PlanLexerEmptyArray = 41 - PlanLexerJSONContains = 42 - PlanLexerJSONContainsAll = 43 - PlanLexerJSONContainsAny = 44 - PlanLexerArrayContains = 45 - PlanLexerArrayContainsAll = 46 - PlanLexerArrayContainsAny = 47 - PlanLexerArrayLength = 48 - PlanLexerElementFilter = 49 - PlanLexerSTEuqals = 50 - PlanLexerSTTouches = 51 - PlanLexerSTOverlaps = 52 - PlanLexerSTCrosses = 53 - PlanLexerSTContains = 54 - PlanLexerSTIntersects = 55 - PlanLexerSTWithin = 56 - PlanLexerSTDWithin = 57 - PlanLexerSTIsValid = 58 - PlanLexerBooleanConstant = 59 - PlanLexerIntegerConstant = 60 - PlanLexerFloatingConstant = 61 - PlanLexerIdentifier = 62 - PlanLexerMeta = 63 - PlanLexerStringLiteral = 64 - PlanLexerJSONIdentifier = 65 - PlanLexerStructSubFieldIdentifier = 66 - PlanLexerWhitespace = 67 - PlanLexerNewline = 68 + PlanLexerMATCH_ALL = 19 + PlanLexerMATCH_ANY = 20 + PlanLexerMATCH_LEAST = 21 + PlanLexerMATCH_MOST = 22 + PlanLexerMATCH_EXACT = 23 + PlanLexerINTERVAL = 24 + PlanLexerISO = 25 + PlanLexerMINIMUM_SHOULD_MATCH = 26 + PlanLexerTHRESHOLD = 27 + PlanLexerASSIGN = 28 + PlanLexerADD = 29 + PlanLexerSUB = 30 + PlanLexerMUL = 31 + PlanLexerDIV = 32 + PlanLexerMOD = 33 + PlanLexerPOW = 34 + PlanLexerSHL = 35 + PlanLexerSHR = 36 + PlanLexerBAND = 37 + PlanLexerBOR = 38 + PlanLexerBXOR = 39 + PlanLexerAND = 40 + PlanLexerOR = 41 + PlanLexerISNULL = 42 + PlanLexerISNOTNULL = 43 + PlanLexerBNOT = 44 + PlanLexerNOT = 45 + PlanLexerIN = 46 + PlanLexerEmptyArray = 47 + PlanLexerJSONContains = 48 + PlanLexerJSONContainsAll = 49 + PlanLexerJSONContainsAny = 50 + PlanLexerArrayContains = 51 + PlanLexerArrayContainsAll = 52 + PlanLexerArrayContainsAny = 53 + PlanLexerArrayLength = 54 + PlanLexerElementFilter = 55 + PlanLexerSTEuqals = 56 + PlanLexerSTTouches = 57 + PlanLexerSTOverlaps = 58 + PlanLexerSTCrosses = 59 + PlanLexerSTContains = 60 + PlanLexerSTIntersects = 61 + PlanLexerSTWithin = 62 + PlanLexerSTDWithin = 63 + PlanLexerSTIsValid = 64 + PlanLexerBooleanConstant = 65 + PlanLexerIntegerConstant = 66 + PlanLexerFloatingConstant = 67 + PlanLexerIdentifier = 68 + PlanLexerMeta = 69 + PlanLexerStringLiteral = 70 + PlanLexerJSONIdentifier = 71 + PlanLexerStructSubFieldIdentifier = 72 + PlanLexerWhitespace = 73 + PlanLexerNewline = 74 ) diff --git a/internal/parser/planparserv2/generated/plan_parser.go b/internal/parser/planparserv2/generated/plan_parser.go index 3490f57b96..66dfb37151 100644 --- a/internal/parser/planparserv2/generated/plan_parser.go +++ b/internal/parser/planparserv2/generated/plan_parser.go @@ -33,30 +33,32 @@ func planParserInit() { staticData := &PlanParserStaticData staticData.LiteralNames = []string{ "", "'('", "')'", "'['", "','", "']'", "'{'", "'}'", "'<'", "'<='", - "'>'", "'>='", "'=='", "'!='", "", "", "", "", "", "", "", "", "'='", - "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'", "'&'", "'|'", - "'^'", "", "", "", "", "'~'", "", "", "", "", "", "", "", "", "", "", - "", "", "", "", "", "", "", "", "", "", "", "", "", "", "'$meta'", + "'>'", "'>='", "'=='", "'!='", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "'='", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", + "'>>'", "'&'", "'|'", "'^'", "", "", "", "", "'~'", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "'$meta'", } staticData.SymbolicNames = []string{ "", "", "", "", "", "", "LBRACE", "RBRACE", "LT", "LE", "GT", "GE", "EQ", "NE", "LIKE", "EXISTS", "TEXTMATCH", "PHRASEMATCH", "RANDOMSAMPLE", - "INTERVAL", "ISO", "MINIMUM_SHOULD_MATCH", "ASSIGN", "ADD", "SUB", "MUL", - "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR", "BXOR", "AND", "OR", - "ISNULL", "ISNOTNULL", "BNOT", "NOT", "IN", "EmptyArray", "JSONContains", - "JSONContainsAll", "JSONContainsAny", "ArrayContains", "ArrayContainsAll", - "ArrayContainsAny", "ArrayLength", "ElementFilter", "STEuqals", "STTouches", - "STOverlaps", "STCrosses", "STContains", "STIntersects", "STWithin", - "STDWithin", "STIsValid", "BooleanConstant", "IntegerConstant", "FloatingConstant", - "Identifier", "Meta", "StringLiteral", "JSONIdentifier", "StructSubFieldIdentifier", - "Whitespace", "Newline", + "MATCH_ALL", "MATCH_ANY", "MATCH_LEAST", "MATCH_MOST", "MATCH_EXACT", + "INTERVAL", "ISO", "MINIMUM_SHOULD_MATCH", "THRESHOLD", "ASSIGN", "ADD", + "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR", "BXOR", + "AND", "OR", "ISNULL", "ISNOTNULL", "BNOT", "NOT", "IN", "EmptyArray", + "JSONContains", "JSONContainsAll", "JSONContainsAny", "ArrayContains", + "ArrayContainsAll", "ArrayContainsAny", "ArrayLength", "ElementFilter", + "STEuqals", "STTouches", "STOverlaps", "STCrosses", "STContains", "STIntersects", + "STWithin", "STDWithin", "STIsValid", "BooleanConstant", "IntegerConstant", + "FloatingConstant", "Identifier", "Meta", "StringLiteral", "JSONIdentifier", + "StructSubFieldIdentifier", "Whitespace", "Newline", } staticData.RuleNames = []string{ "expr", "textMatchOption", } staticData.PredictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ - 4, 1, 68, 252, 2, 0, 7, 0, 2, 1, 7, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, + 4, 1, 74, 299, 2, 0, 7, 0, 2, 1, 7, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 10, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 22, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 42, 8, 0, 10, @@ -71,111 +73,131 @@ func planParserInit() { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, - 5, 0, 174, 8, 0, 10, 0, 12, 0, 177, 9, 0, 1, 0, 3, 0, 180, 8, 0, 3, 0, - 182, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 189, 8, 0, 1, 0, 1, 0, 1, - 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, - 0, 205, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, - 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, - 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, - 0, 1, 0, 1, 0, 5, 0, 243, 8, 0, 10, 0, 12, 0, 246, 9, 0, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 0, 1, 0, 2, 0, 2, 0, 15, 1, 0, 23, 24, 1, 0, 8, 13, 1, 0, - 62, 63, 2, 0, 23, 24, 38, 39, 2, 0, 42, 42, 45, 45, 2, 0, 43, 43, 46, 46, - 2, 0, 44, 44, 47, 47, 2, 0, 62, 62, 65, 65, 1, 0, 25, 27, 1, 0, 29, 30, - 1, 0, 8, 9, 2, 0, 62, 62, 65, 66, 1, 0, 10, 11, 1, 0, 8, 11, 1, 0, 12, - 13, 308, 0, 188, 1, 0, 0, 0, 2, 247, 1, 0, 0, 0, 4, 5, 6, 0, -1, 0, 5, - 9, 5, 62, 0, 0, 6, 7, 7, 0, 0, 0, 7, 8, 5, 19, 0, 0, 8, 10, 5, 64, 0, 0, - 9, 6, 1, 0, 0, 0, 9, 10, 1, 0, 0, 0, 10, 11, 1, 0, 0, 0, 11, 12, 7, 1, - 0, 0, 12, 13, 5, 20, 0, 0, 13, 189, 5, 64, 0, 0, 14, 15, 5, 20, 0, 0, 15, - 16, 5, 64, 0, 0, 16, 17, 7, 1, 0, 0, 17, 21, 5, 62, 0, 0, 18, 19, 7, 0, - 0, 0, 19, 20, 5, 19, 0, 0, 20, 22, 5, 64, 0, 0, 21, 18, 1, 0, 0, 0, 21, - 22, 1, 0, 0, 0, 22, 189, 1, 0, 0, 0, 23, 189, 5, 60, 0, 0, 24, 189, 5, - 61, 0, 0, 25, 189, 5, 59, 0, 0, 26, 189, 5, 64, 0, 0, 27, 189, 7, 2, 0, - 0, 28, 189, 5, 65, 0, 0, 29, 189, 5, 66, 0, 0, 30, 31, 5, 6, 0, 0, 31, - 32, 5, 62, 0, 0, 32, 189, 5, 7, 0, 0, 33, 34, 5, 1, 0, 0, 34, 35, 3, 0, - 0, 0, 35, 36, 5, 2, 0, 0, 36, 189, 1, 0, 0, 0, 37, 38, 5, 3, 0, 0, 38, - 43, 3, 0, 0, 0, 39, 40, 5, 4, 0, 0, 40, 42, 3, 0, 0, 0, 41, 39, 1, 0, 0, - 0, 42, 45, 1, 0, 0, 0, 43, 41, 1, 0, 0, 0, 43, 44, 1, 0, 0, 0, 44, 47, - 1, 0, 0, 0, 45, 43, 1, 0, 0, 0, 46, 48, 5, 4, 0, 0, 47, 46, 1, 0, 0, 0, - 47, 48, 1, 0, 0, 0, 48, 49, 1, 0, 0, 0, 49, 50, 5, 5, 0, 0, 50, 189, 1, - 0, 0, 0, 51, 189, 5, 41, 0, 0, 52, 53, 5, 15, 0, 0, 53, 189, 3, 0, 0, 37, - 54, 55, 5, 16, 0, 0, 55, 56, 5, 1, 0, 0, 56, 57, 5, 62, 0, 0, 57, 58, 5, - 4, 0, 0, 58, 61, 5, 64, 0, 0, 59, 60, 5, 4, 0, 0, 60, 62, 3, 2, 1, 0, 61, - 59, 1, 0, 0, 0, 61, 62, 1, 0, 0, 0, 62, 63, 1, 0, 0, 0, 63, 189, 5, 2, - 0, 0, 64, 65, 5, 17, 0, 0, 65, 66, 5, 1, 0, 0, 66, 67, 5, 62, 0, 0, 67, - 68, 5, 4, 0, 0, 68, 71, 5, 64, 0, 0, 69, 70, 5, 4, 0, 0, 70, 72, 3, 0, - 0, 0, 71, 69, 1, 0, 0, 0, 71, 72, 1, 0, 0, 0, 72, 73, 1, 0, 0, 0, 73, 189, - 5, 2, 0, 0, 74, 75, 5, 18, 0, 0, 75, 76, 5, 1, 0, 0, 76, 77, 3, 0, 0, 0, - 77, 78, 5, 2, 0, 0, 78, 189, 1, 0, 0, 0, 79, 80, 5, 49, 0, 0, 80, 81, 5, - 1, 0, 0, 81, 82, 5, 62, 0, 0, 82, 83, 5, 4, 0, 0, 83, 84, 3, 0, 0, 0, 84, - 85, 5, 2, 0, 0, 85, 189, 1, 0, 0, 0, 86, 87, 7, 3, 0, 0, 87, 189, 3, 0, - 0, 30, 88, 89, 7, 4, 0, 0, 89, 90, 5, 1, 0, 0, 90, 91, 3, 0, 0, 0, 91, - 92, 5, 4, 0, 0, 92, 93, 3, 0, 0, 0, 93, 94, 5, 2, 0, 0, 94, 189, 1, 0, - 0, 0, 95, 96, 7, 5, 0, 0, 96, 97, 5, 1, 0, 0, 97, 98, 3, 0, 0, 0, 98, 99, - 5, 4, 0, 0, 99, 100, 3, 0, 0, 0, 100, 101, 5, 2, 0, 0, 101, 189, 1, 0, - 0, 0, 102, 103, 7, 6, 0, 0, 103, 104, 5, 1, 0, 0, 104, 105, 3, 0, 0, 0, - 105, 106, 5, 4, 0, 0, 106, 107, 3, 0, 0, 0, 107, 108, 5, 2, 0, 0, 108, - 189, 1, 0, 0, 0, 109, 110, 5, 50, 0, 0, 110, 111, 5, 1, 0, 0, 111, 112, - 5, 62, 0, 0, 112, 113, 5, 4, 0, 0, 113, 114, 5, 64, 0, 0, 114, 189, 5, - 2, 0, 0, 115, 116, 5, 51, 0, 0, 116, 117, 5, 1, 0, 0, 117, 118, 5, 62, - 0, 0, 118, 119, 5, 4, 0, 0, 119, 120, 5, 64, 0, 0, 120, 189, 5, 2, 0, 0, - 121, 122, 5, 52, 0, 0, 122, 123, 5, 1, 0, 0, 123, 124, 5, 62, 0, 0, 124, - 125, 5, 4, 0, 0, 125, 126, 5, 64, 0, 0, 126, 189, 5, 2, 0, 0, 127, 128, - 5, 53, 0, 0, 128, 129, 5, 1, 0, 0, 129, 130, 5, 62, 0, 0, 130, 131, 5, - 4, 0, 0, 131, 132, 5, 64, 0, 0, 132, 189, 5, 2, 0, 0, 133, 134, 5, 54, - 0, 0, 134, 135, 5, 1, 0, 0, 135, 136, 5, 62, 0, 0, 136, 137, 5, 4, 0, 0, - 137, 138, 5, 64, 0, 0, 138, 189, 5, 2, 0, 0, 139, 140, 5, 55, 0, 0, 140, - 141, 5, 1, 0, 0, 141, 142, 5, 62, 0, 0, 142, 143, 5, 4, 0, 0, 143, 144, - 5, 64, 0, 0, 144, 189, 5, 2, 0, 0, 145, 146, 5, 56, 0, 0, 146, 147, 5, - 1, 0, 0, 147, 148, 5, 62, 0, 0, 148, 149, 5, 4, 0, 0, 149, 150, 5, 64, - 0, 0, 150, 189, 5, 2, 0, 0, 151, 152, 5, 57, 0, 0, 152, 153, 5, 1, 0, 0, - 153, 154, 5, 62, 0, 0, 154, 155, 5, 4, 0, 0, 155, 156, 5, 64, 0, 0, 156, - 157, 5, 4, 0, 0, 157, 158, 3, 0, 0, 0, 158, 159, 5, 2, 0, 0, 159, 189, - 1, 0, 0, 0, 160, 161, 5, 58, 0, 0, 161, 162, 5, 1, 0, 0, 162, 163, 5, 62, - 0, 0, 163, 189, 5, 2, 0, 0, 164, 165, 5, 48, 0, 0, 165, 166, 5, 1, 0, 0, - 166, 167, 7, 7, 0, 0, 167, 189, 5, 2, 0, 0, 168, 169, 5, 62, 0, 0, 169, - 181, 5, 1, 0, 0, 170, 175, 3, 0, 0, 0, 171, 172, 5, 4, 0, 0, 172, 174, - 3, 0, 0, 0, 173, 171, 1, 0, 0, 0, 174, 177, 1, 0, 0, 0, 175, 173, 1, 0, - 0, 0, 175, 176, 1, 0, 0, 0, 176, 179, 1, 0, 0, 0, 177, 175, 1, 0, 0, 0, - 178, 180, 5, 4, 0, 0, 179, 178, 1, 0, 0, 0, 179, 180, 1, 0, 0, 0, 180, - 182, 1, 0, 0, 0, 181, 170, 1, 0, 0, 0, 181, 182, 1, 0, 0, 0, 182, 183, - 1, 0, 0, 0, 183, 189, 5, 2, 0, 0, 184, 185, 7, 7, 0, 0, 185, 189, 5, 36, - 0, 0, 186, 187, 7, 7, 0, 0, 187, 189, 5, 37, 0, 0, 188, 4, 1, 0, 0, 0, - 188, 14, 1, 0, 0, 0, 188, 23, 1, 0, 0, 0, 188, 24, 1, 0, 0, 0, 188, 25, - 1, 0, 0, 0, 188, 26, 1, 0, 0, 0, 188, 27, 1, 0, 0, 0, 188, 28, 1, 0, 0, - 0, 188, 29, 1, 0, 0, 0, 188, 30, 1, 0, 0, 0, 188, 33, 1, 0, 0, 0, 188, - 37, 1, 0, 0, 0, 188, 51, 1, 0, 0, 0, 188, 52, 1, 0, 0, 0, 188, 54, 1, 0, - 0, 0, 188, 64, 1, 0, 0, 0, 188, 74, 1, 0, 0, 0, 188, 79, 1, 0, 0, 0, 188, - 86, 1, 0, 0, 0, 188, 88, 1, 0, 0, 0, 188, 95, 1, 0, 0, 0, 188, 102, 1, - 0, 0, 0, 188, 109, 1, 0, 0, 0, 188, 115, 1, 0, 0, 0, 188, 121, 1, 0, 0, - 0, 188, 127, 1, 0, 0, 0, 188, 133, 1, 0, 0, 0, 188, 139, 1, 0, 0, 0, 188, - 145, 1, 0, 0, 0, 188, 151, 1, 0, 0, 0, 188, 160, 1, 0, 0, 0, 188, 164, - 1, 0, 0, 0, 188, 168, 1, 0, 0, 0, 188, 184, 1, 0, 0, 0, 188, 186, 1, 0, - 0, 0, 189, 244, 1, 0, 0, 0, 190, 191, 10, 31, 0, 0, 191, 192, 5, 28, 0, - 0, 192, 243, 3, 0, 0, 32, 193, 194, 10, 29, 0, 0, 194, 195, 7, 8, 0, 0, - 195, 243, 3, 0, 0, 30, 196, 197, 10, 28, 0, 0, 197, 198, 7, 0, 0, 0, 198, - 243, 3, 0, 0, 29, 199, 200, 10, 27, 0, 0, 200, 201, 7, 9, 0, 0, 201, 243, - 3, 0, 0, 28, 202, 204, 10, 26, 0, 0, 203, 205, 5, 39, 0, 0, 204, 203, 1, - 0, 0, 0, 204, 205, 1, 0, 0, 0, 205, 206, 1, 0, 0, 0, 206, 207, 5, 40, 0, - 0, 207, 243, 3, 0, 0, 27, 208, 209, 10, 11, 0, 0, 209, 210, 7, 10, 0, 0, - 210, 211, 7, 11, 0, 0, 211, 212, 7, 10, 0, 0, 212, 243, 3, 0, 0, 12, 213, - 214, 10, 10, 0, 0, 214, 215, 7, 12, 0, 0, 215, 216, 7, 11, 0, 0, 216, 217, - 7, 12, 0, 0, 217, 243, 3, 0, 0, 11, 218, 219, 10, 9, 0, 0, 219, 220, 7, - 13, 0, 0, 220, 243, 3, 0, 0, 10, 221, 222, 10, 8, 0, 0, 222, 223, 7, 14, - 0, 0, 223, 243, 3, 0, 0, 9, 224, 225, 10, 7, 0, 0, 225, 226, 5, 31, 0, - 0, 226, 243, 3, 0, 0, 8, 227, 228, 10, 6, 0, 0, 228, 229, 5, 33, 0, 0, - 229, 243, 3, 0, 0, 7, 230, 231, 10, 5, 0, 0, 231, 232, 5, 32, 0, 0, 232, - 243, 3, 0, 0, 6, 233, 234, 10, 4, 0, 0, 234, 235, 5, 34, 0, 0, 235, 243, - 3, 0, 0, 5, 236, 237, 10, 3, 0, 0, 237, 238, 5, 35, 0, 0, 238, 243, 3, - 0, 0, 4, 239, 240, 10, 36, 0, 0, 240, 241, 5, 14, 0, 0, 241, 243, 5, 64, - 0, 0, 242, 190, 1, 0, 0, 0, 242, 193, 1, 0, 0, 0, 242, 196, 1, 0, 0, 0, - 242, 199, 1, 0, 0, 0, 242, 202, 1, 0, 0, 0, 242, 208, 1, 0, 0, 0, 242, - 213, 1, 0, 0, 0, 242, 218, 1, 0, 0, 0, 242, 221, 1, 0, 0, 0, 242, 224, - 1, 0, 0, 0, 242, 227, 1, 0, 0, 0, 242, 230, 1, 0, 0, 0, 242, 233, 1, 0, - 0, 0, 242, 236, 1, 0, 0, 0, 242, 239, 1, 0, 0, 0, 243, 246, 1, 0, 0, 0, - 244, 242, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245, 1, 1, 0, 0, 0, 246, 244, - 1, 0, 0, 0, 247, 248, 5, 21, 0, 0, 248, 249, 5, 22, 0, 0, 249, 250, 5, - 60, 0, 0, 250, 3, 1, 0, 0, 0, 13, 9, 21, 43, 47, 61, 71, 175, 179, 181, - 188, 204, 242, 244, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, + 221, 8, 0, 10, 0, 12, 0, 224, 9, 0, 1, 0, 3, 0, 227, 8, 0, 3, 0, 229, 8, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 236, 8, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 252, + 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 5, 0, 290, 8, 0, 10, 0, 12, 0, 293, 9, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 1, 0, 2, 0, 2, 0, 15, 1, 0, 29, 30, 1, 0, 8, 13, 1, 0, 68, 69, + 2, 0, 29, 30, 44, 45, 2, 0, 48, 48, 51, 51, 2, 0, 49, 49, 52, 52, 2, 0, + 50, 50, 53, 53, 2, 0, 68, 68, 71, 71, 1, 0, 31, 33, 1, 0, 35, 36, 1, 0, + 8, 9, 2, 0, 68, 68, 71, 72, 1, 0, 10, 11, 1, 0, 8, 11, 1, 0, 12, 13, 360, + 0, 235, 1, 0, 0, 0, 2, 294, 1, 0, 0, 0, 4, 5, 6, 0, -1, 0, 5, 9, 5, 68, + 0, 0, 6, 7, 7, 0, 0, 0, 7, 8, 5, 24, 0, 0, 8, 10, 5, 70, 0, 0, 9, 6, 1, + 0, 0, 0, 9, 10, 1, 0, 0, 0, 10, 11, 1, 0, 0, 0, 11, 12, 7, 1, 0, 0, 12, + 13, 5, 25, 0, 0, 13, 236, 5, 70, 0, 0, 14, 15, 5, 25, 0, 0, 15, 16, 5, + 70, 0, 0, 16, 17, 7, 1, 0, 0, 17, 21, 5, 68, 0, 0, 18, 19, 7, 0, 0, 0, + 19, 20, 5, 24, 0, 0, 20, 22, 5, 70, 0, 0, 21, 18, 1, 0, 0, 0, 21, 22, 1, + 0, 0, 0, 22, 236, 1, 0, 0, 0, 23, 236, 5, 66, 0, 0, 24, 236, 5, 67, 0, + 0, 25, 236, 5, 65, 0, 0, 26, 236, 5, 70, 0, 0, 27, 236, 7, 2, 0, 0, 28, + 236, 5, 71, 0, 0, 29, 236, 5, 72, 0, 0, 30, 31, 5, 6, 0, 0, 31, 32, 5, + 68, 0, 0, 32, 236, 5, 7, 0, 0, 33, 34, 5, 1, 0, 0, 34, 35, 3, 0, 0, 0, + 35, 36, 5, 2, 0, 0, 36, 236, 1, 0, 0, 0, 37, 38, 5, 3, 0, 0, 38, 43, 3, + 0, 0, 0, 39, 40, 5, 4, 0, 0, 40, 42, 3, 0, 0, 0, 41, 39, 1, 0, 0, 0, 42, + 45, 1, 0, 0, 0, 43, 41, 1, 0, 0, 0, 43, 44, 1, 0, 0, 0, 44, 47, 1, 0, 0, + 0, 45, 43, 1, 0, 0, 0, 46, 48, 5, 4, 0, 0, 47, 46, 1, 0, 0, 0, 47, 48, + 1, 0, 0, 0, 48, 49, 1, 0, 0, 0, 49, 50, 5, 5, 0, 0, 50, 236, 1, 0, 0, 0, + 51, 236, 5, 47, 0, 0, 52, 53, 5, 15, 0, 0, 53, 236, 3, 0, 0, 42, 54, 55, + 5, 16, 0, 0, 55, 56, 5, 1, 0, 0, 56, 57, 5, 68, 0, 0, 57, 58, 5, 4, 0, + 0, 58, 61, 5, 70, 0, 0, 59, 60, 5, 4, 0, 0, 60, 62, 3, 2, 1, 0, 61, 59, + 1, 0, 0, 0, 61, 62, 1, 0, 0, 0, 62, 63, 1, 0, 0, 0, 63, 236, 5, 2, 0, 0, + 64, 65, 5, 17, 0, 0, 65, 66, 5, 1, 0, 0, 66, 67, 5, 68, 0, 0, 67, 68, 5, + 4, 0, 0, 68, 71, 5, 70, 0, 0, 69, 70, 5, 4, 0, 0, 70, 72, 3, 0, 0, 0, 71, + 69, 1, 0, 0, 0, 71, 72, 1, 0, 0, 0, 72, 73, 1, 0, 0, 0, 73, 236, 5, 2, + 0, 0, 74, 75, 5, 18, 0, 0, 75, 76, 5, 1, 0, 0, 76, 77, 3, 0, 0, 0, 77, + 78, 5, 2, 0, 0, 78, 236, 1, 0, 0, 0, 79, 80, 5, 55, 0, 0, 80, 81, 5, 1, + 0, 0, 81, 82, 5, 68, 0, 0, 82, 83, 5, 4, 0, 0, 83, 84, 3, 0, 0, 0, 84, + 85, 5, 2, 0, 0, 85, 236, 1, 0, 0, 0, 86, 87, 5, 19, 0, 0, 87, 88, 5, 1, + 0, 0, 88, 89, 5, 68, 0, 0, 89, 90, 5, 4, 0, 0, 90, 91, 3, 0, 0, 0, 91, + 92, 5, 2, 0, 0, 92, 236, 1, 0, 0, 0, 93, 94, 5, 20, 0, 0, 94, 95, 5, 1, + 0, 0, 95, 96, 5, 68, 0, 0, 96, 97, 5, 4, 0, 0, 97, 98, 3, 0, 0, 0, 98, + 99, 5, 2, 0, 0, 99, 236, 1, 0, 0, 0, 100, 101, 5, 21, 0, 0, 101, 102, 5, + 1, 0, 0, 102, 103, 5, 68, 0, 0, 103, 104, 5, 4, 0, 0, 104, 105, 3, 0, 0, + 0, 105, 106, 5, 4, 0, 0, 106, 107, 5, 27, 0, 0, 107, 108, 5, 28, 0, 0, + 108, 109, 5, 66, 0, 0, 109, 110, 5, 2, 0, 0, 110, 236, 1, 0, 0, 0, 111, + 112, 5, 22, 0, 0, 112, 113, 5, 1, 0, 0, 113, 114, 5, 68, 0, 0, 114, 115, + 5, 4, 0, 0, 115, 116, 3, 0, 0, 0, 116, 117, 5, 4, 0, 0, 117, 118, 5, 27, + 0, 0, 118, 119, 5, 28, 0, 0, 119, 120, 5, 66, 0, 0, 120, 121, 5, 2, 0, + 0, 121, 236, 1, 0, 0, 0, 122, 123, 5, 23, 0, 0, 123, 124, 5, 1, 0, 0, 124, + 125, 5, 68, 0, 0, 125, 126, 5, 4, 0, 0, 126, 127, 3, 0, 0, 0, 127, 128, + 5, 4, 0, 0, 128, 129, 5, 27, 0, 0, 129, 130, 5, 28, 0, 0, 130, 131, 5, + 66, 0, 0, 131, 132, 5, 2, 0, 0, 132, 236, 1, 0, 0, 0, 133, 134, 7, 3, 0, + 0, 134, 236, 3, 0, 0, 30, 135, 136, 7, 4, 0, 0, 136, 137, 5, 1, 0, 0, 137, + 138, 3, 0, 0, 0, 138, 139, 5, 4, 0, 0, 139, 140, 3, 0, 0, 0, 140, 141, + 5, 2, 0, 0, 141, 236, 1, 0, 0, 0, 142, 143, 7, 5, 0, 0, 143, 144, 5, 1, + 0, 0, 144, 145, 3, 0, 0, 0, 145, 146, 5, 4, 0, 0, 146, 147, 3, 0, 0, 0, + 147, 148, 5, 2, 0, 0, 148, 236, 1, 0, 0, 0, 149, 150, 7, 6, 0, 0, 150, + 151, 5, 1, 0, 0, 151, 152, 3, 0, 0, 0, 152, 153, 5, 4, 0, 0, 153, 154, + 3, 0, 0, 0, 154, 155, 5, 2, 0, 0, 155, 236, 1, 0, 0, 0, 156, 157, 5, 56, + 0, 0, 157, 158, 5, 1, 0, 0, 158, 159, 5, 68, 0, 0, 159, 160, 5, 4, 0, 0, + 160, 161, 5, 70, 0, 0, 161, 236, 5, 2, 0, 0, 162, 163, 5, 57, 0, 0, 163, + 164, 5, 1, 0, 0, 164, 165, 5, 68, 0, 0, 165, 166, 5, 4, 0, 0, 166, 167, + 5, 70, 0, 0, 167, 236, 5, 2, 0, 0, 168, 169, 5, 58, 0, 0, 169, 170, 5, + 1, 0, 0, 170, 171, 5, 68, 0, 0, 171, 172, 5, 4, 0, 0, 172, 173, 5, 70, + 0, 0, 173, 236, 5, 2, 0, 0, 174, 175, 5, 59, 0, 0, 175, 176, 5, 1, 0, 0, + 176, 177, 5, 68, 0, 0, 177, 178, 5, 4, 0, 0, 178, 179, 5, 70, 0, 0, 179, + 236, 5, 2, 0, 0, 180, 181, 5, 60, 0, 0, 181, 182, 5, 1, 0, 0, 182, 183, + 5, 68, 0, 0, 183, 184, 5, 4, 0, 0, 184, 185, 5, 70, 0, 0, 185, 236, 5, + 2, 0, 0, 186, 187, 5, 61, 0, 0, 187, 188, 5, 1, 0, 0, 188, 189, 5, 68, + 0, 0, 189, 190, 5, 4, 0, 0, 190, 191, 5, 70, 0, 0, 191, 236, 5, 2, 0, 0, + 192, 193, 5, 62, 0, 0, 193, 194, 5, 1, 0, 0, 194, 195, 5, 68, 0, 0, 195, + 196, 5, 4, 0, 0, 196, 197, 5, 70, 0, 0, 197, 236, 5, 2, 0, 0, 198, 199, + 5, 63, 0, 0, 199, 200, 5, 1, 0, 0, 200, 201, 5, 68, 0, 0, 201, 202, 5, + 4, 0, 0, 202, 203, 5, 70, 0, 0, 203, 204, 5, 4, 0, 0, 204, 205, 3, 0, 0, + 0, 205, 206, 5, 2, 0, 0, 206, 236, 1, 0, 0, 0, 207, 208, 5, 64, 0, 0, 208, + 209, 5, 1, 0, 0, 209, 210, 5, 68, 0, 0, 210, 236, 5, 2, 0, 0, 211, 212, + 5, 54, 0, 0, 212, 213, 5, 1, 0, 0, 213, 214, 7, 7, 0, 0, 214, 236, 5, 2, + 0, 0, 215, 216, 5, 68, 0, 0, 216, 228, 5, 1, 0, 0, 217, 222, 3, 0, 0, 0, + 218, 219, 5, 4, 0, 0, 219, 221, 3, 0, 0, 0, 220, 218, 1, 0, 0, 0, 221, + 224, 1, 0, 0, 0, 222, 220, 1, 0, 0, 0, 222, 223, 1, 0, 0, 0, 223, 226, + 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 225, 227, 5, 4, 0, 0, 226, 225, 1, 0, + 0, 0, 226, 227, 1, 0, 0, 0, 227, 229, 1, 0, 0, 0, 228, 217, 1, 0, 0, 0, + 228, 229, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 236, 5, 2, 0, 0, 231, + 232, 7, 7, 0, 0, 232, 236, 5, 42, 0, 0, 233, 234, 7, 7, 0, 0, 234, 236, + 5, 43, 0, 0, 235, 4, 1, 0, 0, 0, 235, 14, 1, 0, 0, 0, 235, 23, 1, 0, 0, + 0, 235, 24, 1, 0, 0, 0, 235, 25, 1, 0, 0, 0, 235, 26, 1, 0, 0, 0, 235, + 27, 1, 0, 0, 0, 235, 28, 1, 0, 0, 0, 235, 29, 1, 0, 0, 0, 235, 30, 1, 0, + 0, 0, 235, 33, 1, 0, 0, 0, 235, 37, 1, 0, 0, 0, 235, 51, 1, 0, 0, 0, 235, + 52, 1, 0, 0, 0, 235, 54, 1, 0, 0, 0, 235, 64, 1, 0, 0, 0, 235, 74, 1, 0, + 0, 0, 235, 79, 1, 0, 0, 0, 235, 86, 1, 0, 0, 0, 235, 93, 1, 0, 0, 0, 235, + 100, 1, 0, 0, 0, 235, 111, 1, 0, 0, 0, 235, 122, 1, 0, 0, 0, 235, 133, + 1, 0, 0, 0, 235, 135, 1, 0, 0, 0, 235, 142, 1, 0, 0, 0, 235, 149, 1, 0, + 0, 0, 235, 156, 1, 0, 0, 0, 235, 162, 1, 0, 0, 0, 235, 168, 1, 0, 0, 0, + 235, 174, 1, 0, 0, 0, 235, 180, 1, 0, 0, 0, 235, 186, 1, 0, 0, 0, 235, + 192, 1, 0, 0, 0, 235, 198, 1, 0, 0, 0, 235, 207, 1, 0, 0, 0, 235, 211, + 1, 0, 0, 0, 235, 215, 1, 0, 0, 0, 235, 231, 1, 0, 0, 0, 235, 233, 1, 0, + 0, 0, 236, 291, 1, 0, 0, 0, 237, 238, 10, 31, 0, 0, 238, 239, 5, 34, 0, + 0, 239, 290, 3, 0, 0, 32, 240, 241, 10, 29, 0, 0, 241, 242, 7, 8, 0, 0, + 242, 290, 3, 0, 0, 30, 243, 244, 10, 28, 0, 0, 244, 245, 7, 0, 0, 0, 245, + 290, 3, 0, 0, 29, 246, 247, 10, 27, 0, 0, 247, 248, 7, 9, 0, 0, 248, 290, + 3, 0, 0, 28, 249, 251, 10, 26, 0, 0, 250, 252, 5, 45, 0, 0, 251, 250, 1, + 0, 0, 0, 251, 252, 1, 0, 0, 0, 252, 253, 1, 0, 0, 0, 253, 254, 5, 46, 0, + 0, 254, 290, 3, 0, 0, 27, 255, 256, 10, 11, 0, 0, 256, 257, 7, 10, 0, 0, + 257, 258, 7, 11, 0, 0, 258, 259, 7, 10, 0, 0, 259, 290, 3, 0, 0, 12, 260, + 261, 10, 10, 0, 0, 261, 262, 7, 12, 0, 0, 262, 263, 7, 11, 0, 0, 263, 264, + 7, 12, 0, 0, 264, 290, 3, 0, 0, 11, 265, 266, 10, 9, 0, 0, 266, 267, 7, + 13, 0, 0, 267, 290, 3, 0, 0, 10, 268, 269, 10, 8, 0, 0, 269, 270, 7, 14, + 0, 0, 270, 290, 3, 0, 0, 9, 271, 272, 10, 7, 0, 0, 272, 273, 5, 37, 0, + 0, 273, 290, 3, 0, 0, 8, 274, 275, 10, 6, 0, 0, 275, 276, 5, 39, 0, 0, + 276, 290, 3, 0, 0, 7, 277, 278, 10, 5, 0, 0, 278, 279, 5, 38, 0, 0, 279, + 290, 3, 0, 0, 6, 280, 281, 10, 4, 0, 0, 281, 282, 5, 40, 0, 0, 282, 290, + 3, 0, 0, 5, 283, 284, 10, 3, 0, 0, 284, 285, 5, 41, 0, 0, 285, 290, 3, + 0, 0, 4, 286, 287, 10, 41, 0, 0, 287, 288, 5, 14, 0, 0, 288, 290, 5, 70, + 0, 0, 289, 237, 1, 0, 0, 0, 289, 240, 1, 0, 0, 0, 289, 243, 1, 0, 0, 0, + 289, 246, 1, 0, 0, 0, 289, 249, 1, 0, 0, 0, 289, 255, 1, 0, 0, 0, 289, + 260, 1, 0, 0, 0, 289, 265, 1, 0, 0, 0, 289, 268, 1, 0, 0, 0, 289, 271, + 1, 0, 0, 0, 289, 274, 1, 0, 0, 0, 289, 277, 1, 0, 0, 0, 289, 280, 1, 0, + 0, 0, 289, 283, 1, 0, 0, 0, 289, 286, 1, 0, 0, 0, 290, 293, 1, 0, 0, 0, + 291, 289, 1, 0, 0, 0, 291, 292, 1, 0, 0, 0, 292, 1, 1, 0, 0, 0, 293, 291, + 1, 0, 0, 0, 294, 295, 5, 26, 0, 0, 295, 296, 5, 28, 0, 0, 296, 297, 5, + 66, 0, 0, 297, 3, 1, 0, 0, 0, 13, 9, 21, 43, 47, 61, 71, 222, 226, 228, + 235, 251, 289, 291, } deserializer := antlr.NewATNDeserializer(nil) staticData.atn = deserializer.Deserialize(staticData.serializedATN) @@ -232,56 +254,62 @@ const ( PlanParserTEXTMATCH = 16 PlanParserPHRASEMATCH = 17 PlanParserRANDOMSAMPLE = 18 - PlanParserINTERVAL = 19 - PlanParserISO = 20 - PlanParserMINIMUM_SHOULD_MATCH = 21 - PlanParserASSIGN = 22 - PlanParserADD = 23 - PlanParserSUB = 24 - PlanParserMUL = 25 - PlanParserDIV = 26 - PlanParserMOD = 27 - PlanParserPOW = 28 - PlanParserSHL = 29 - PlanParserSHR = 30 - PlanParserBAND = 31 - PlanParserBOR = 32 - PlanParserBXOR = 33 - PlanParserAND = 34 - PlanParserOR = 35 - PlanParserISNULL = 36 - PlanParserISNOTNULL = 37 - PlanParserBNOT = 38 - PlanParserNOT = 39 - PlanParserIN = 40 - PlanParserEmptyArray = 41 - PlanParserJSONContains = 42 - PlanParserJSONContainsAll = 43 - PlanParserJSONContainsAny = 44 - PlanParserArrayContains = 45 - PlanParserArrayContainsAll = 46 - PlanParserArrayContainsAny = 47 - PlanParserArrayLength = 48 - PlanParserElementFilter = 49 - PlanParserSTEuqals = 50 - PlanParserSTTouches = 51 - PlanParserSTOverlaps = 52 - PlanParserSTCrosses = 53 - PlanParserSTContains = 54 - PlanParserSTIntersects = 55 - PlanParserSTWithin = 56 - PlanParserSTDWithin = 57 - PlanParserSTIsValid = 58 - PlanParserBooleanConstant = 59 - PlanParserIntegerConstant = 60 - PlanParserFloatingConstant = 61 - PlanParserIdentifier = 62 - PlanParserMeta = 63 - PlanParserStringLiteral = 64 - PlanParserJSONIdentifier = 65 - PlanParserStructSubFieldIdentifier = 66 - PlanParserWhitespace = 67 - PlanParserNewline = 68 + PlanParserMATCH_ALL = 19 + PlanParserMATCH_ANY = 20 + PlanParserMATCH_LEAST = 21 + PlanParserMATCH_MOST = 22 + PlanParserMATCH_EXACT = 23 + PlanParserINTERVAL = 24 + PlanParserISO = 25 + PlanParserMINIMUM_SHOULD_MATCH = 26 + PlanParserTHRESHOLD = 27 + PlanParserASSIGN = 28 + PlanParserADD = 29 + PlanParserSUB = 30 + PlanParserMUL = 31 + PlanParserDIV = 32 + PlanParserMOD = 33 + PlanParserPOW = 34 + PlanParserSHL = 35 + PlanParserSHR = 36 + PlanParserBAND = 37 + PlanParserBOR = 38 + PlanParserBXOR = 39 + PlanParserAND = 40 + PlanParserOR = 41 + PlanParserISNULL = 42 + PlanParserISNOTNULL = 43 + PlanParserBNOT = 44 + PlanParserNOT = 45 + PlanParserIN = 46 + PlanParserEmptyArray = 47 + PlanParserJSONContains = 48 + PlanParserJSONContainsAll = 49 + PlanParserJSONContainsAny = 50 + PlanParserArrayContains = 51 + PlanParserArrayContainsAll = 52 + PlanParserArrayContainsAny = 53 + PlanParserArrayLength = 54 + PlanParserElementFilter = 55 + PlanParserSTEuqals = 56 + PlanParserSTTouches = 57 + PlanParserSTOverlaps = 58 + PlanParserSTCrosses = 59 + PlanParserSTContains = 60 + PlanParserSTIntersects = 61 + PlanParserSTWithin = 62 + PlanParserSTDWithin = 63 + PlanParserSTIsValid = 64 + PlanParserBooleanConstant = 65 + PlanParserIntegerConstant = 66 + PlanParserFloatingConstant = 67 + PlanParserIdentifier = 68 + PlanParserMeta = 69 + PlanParserStringLiteral = 70 + PlanParserJSONIdentifier = 71 + PlanParserStructSubFieldIdentifier = 72 + PlanParserWhitespace = 73 + PlanParserNewline = 74 ) // PlanParser rules. @@ -376,6 +404,58 @@ func (s *StringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } +type MatchAnyContext struct { + ExprContext +} + +func NewMatchAnyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MatchAnyContext { + var p = new(MatchAnyContext) + + InitEmptyExprContext(&p.ExprContext) + p.parser = parser + p.CopyAll(ctx.(*ExprContext)) + + return p +} + +func (s *MatchAnyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MatchAnyContext) MATCH_ANY() antlr.TerminalNode { + return s.GetToken(PlanParserMATCH_ANY, 0) +} + +func (s *MatchAnyContext) Identifier() antlr.TerminalNode { + return s.GetToken(PlanParserIdentifier, 0) +} + +func (s *MatchAnyContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *MatchAnyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlanVisitor: + return t.VisitMatchAny(s) + + default: + return t.VisitChildren(s) + } +} + type FloatingContext struct { ExprContext } @@ -1067,6 +1147,70 @@ func (s *PhraseMatchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } +type MatchLeastContext struct { + ExprContext +} + +func NewMatchLeastContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MatchLeastContext { + var p = new(MatchLeastContext) + + InitEmptyExprContext(&p.ExprContext) + p.parser = parser + p.CopyAll(ctx.(*ExprContext)) + + return p +} + +func (s *MatchLeastContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MatchLeastContext) MATCH_LEAST() antlr.TerminalNode { + return s.GetToken(PlanParserMATCH_LEAST, 0) +} + +func (s *MatchLeastContext) Identifier() antlr.TerminalNode { + return s.GetToken(PlanParserIdentifier, 0) +} + +func (s *MatchLeastContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *MatchLeastContext) THRESHOLD() antlr.TerminalNode { + return s.GetToken(PlanParserTHRESHOLD, 0) +} + +func (s *MatchLeastContext) ASSIGN() antlr.TerminalNode { + return s.GetToken(PlanParserASSIGN, 0) +} + +func (s *MatchLeastContext) IntegerConstant() antlr.TerminalNode { + return s.GetToken(PlanParserIntegerConstant, 0) +} + +func (s *MatchLeastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlanVisitor: + return t.VisitMatchLeast(s) + + default: + return t.VisitChildren(s) + } +} + type ArrayLengthContext struct { ExprContext } @@ -1453,6 +1597,58 @@ func (s *RangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } +type MatchAllContext struct { + ExprContext +} + +func NewMatchAllContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MatchAllContext { + var p = new(MatchAllContext) + + InitEmptyExprContext(&p.ExprContext) + p.parser = parser + p.CopyAll(ctx.(*ExprContext)) + + return p +} + +func (s *MatchAllContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MatchAllContext) MATCH_ALL() antlr.TerminalNode { + return s.GetToken(PlanParserMATCH_ALL, 0) +} + +func (s *MatchAllContext) Identifier() antlr.TerminalNode { + return s.GetToken(PlanParserIdentifier, 0) +} + +func (s *MatchAllContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *MatchAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlanVisitor: + return t.VisitMatchAll(s) + + default: + return t.VisitChildren(s) + } +} + type STIsValidContext struct { ExprContext } @@ -1727,6 +1923,70 @@ func (s *STOverlapsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } +type MatchMostContext struct { + ExprContext +} + +func NewMatchMostContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MatchMostContext { + var p = new(MatchMostContext) + + InitEmptyExprContext(&p.ExprContext) + p.parser = parser + p.CopyAll(ctx.(*ExprContext)) + + return p +} + +func (s *MatchMostContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MatchMostContext) MATCH_MOST() antlr.TerminalNode { + return s.GetToken(PlanParserMATCH_MOST, 0) +} + +func (s *MatchMostContext) Identifier() antlr.TerminalNode { + return s.GetToken(PlanParserIdentifier, 0) +} + +func (s *MatchMostContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *MatchMostContext) THRESHOLD() antlr.TerminalNode { + return s.GetToken(PlanParserTHRESHOLD, 0) +} + +func (s *MatchMostContext) ASSIGN() antlr.TerminalNode { + return s.GetToken(PlanParserASSIGN, 0) +} + +func (s *MatchMostContext) IntegerConstant() antlr.TerminalNode { + return s.GetToken(PlanParserIntegerConstant, 0) +} + +func (s *MatchMostContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlanVisitor: + return t.VisitMatchMost(s) + + default: + return t.VisitChildren(s) + } +} + type JSONIdentifierContext struct { ExprContext } @@ -1851,6 +2111,70 @@ func (s *ParensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } +type MatchExactContext struct { + ExprContext +} + +func NewMatchExactContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MatchExactContext { + var p = new(MatchExactContext) + + InitEmptyExprContext(&p.ExprContext) + p.parser = parser + p.CopyAll(ctx.(*ExprContext)) + + return p +} + +func (s *MatchExactContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MatchExactContext) MATCH_EXACT() antlr.TerminalNode { + return s.GetToken(PlanParserMATCH_EXACT, 0) +} + +func (s *MatchExactContext) Identifier() antlr.TerminalNode { + return s.GetToken(PlanParserIdentifier, 0) +} + +func (s *MatchExactContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *MatchExactContext) THRESHOLD() antlr.TerminalNode { + return s.GetToken(PlanParserTHRESHOLD, 0) +} + +func (s *MatchExactContext) ASSIGN() antlr.TerminalNode { + return s.GetToken(PlanParserASSIGN, 0) +} + +func (s *MatchExactContext) IntegerConstant() antlr.TerminalNode { + return s.GetToken(PlanParserIntegerConstant, 0) +} + +func (s *MatchExactContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlanVisitor: + return t.VisitMatchExact(s) + + default: + return t.VisitChildren(s) + } +} + type JSONContainsAllContext struct { ExprContext } @@ -3304,7 +3628,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { var _alt int p.EnterOuterAlt(localctx, 1) - p.SetState(188) + p.SetState(235) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -3757,7 +4081,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(53) - p.expr(37) + p.expr(42) } case 15: @@ -3993,50 +4317,36 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } case 19: - localctx = NewUnaryContext(p, localctx) + localctx = NewMatchAllContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { p.SetState(86) - - var _lt = p.GetTokenStream().LT(1) - - localctx.(*UnaryContext).op = _lt - - _la = p.GetTokenStream().LA(1) - - if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&824658886656) != 0) { - var _ri = p.GetErrorHandler().RecoverInline(p) - - localctx.(*UnaryContext).op = _ri - } else { - p.GetErrorHandler().ReportMatch(p) - p.Consume() + p.Match(PlanParserMATCH_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } } { p.SetState(87) - p.expr(30) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } } - - case 20: - localctx = NewJSONContainsContext(p, localctx) - p.SetParserRuleContext(localctx) - _prevctx = localctx { p.SetState(88) - _la = p.GetTokenStream().LA(1) - - if !(_la == PlanParserJSONContains || _la == PlanParserArrayContains) { - p.GetErrorHandler().RecoverInline(p) - } else { - p.GetErrorHandler().ReportMatch(p) - p.Consume() + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } } { p.SetState(89) - p.Match(PlanParserT__0) + p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4048,18 +4358,6 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(91) - p.Match(PlanParserT__3) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(92) - p.expr(0) - } - { - p.SetState(93) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4067,24 +4365,37 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - case 21: - localctx = NewJSONContainsAllContext(p, localctx) + case 20: + localctx = NewMatchAnyContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx + { + p.SetState(93) + p.Match(PlanParserMATCH_ANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(94) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } { p.SetState(95) - _la = p.GetTokenStream().LA(1) - - if !(_la == PlanParserJSONContainsAll || _la == PlanParserArrayContainsAll) { - p.GetErrorHandler().RecoverInline(p) - } else { - p.GetErrorHandler().ReportMatch(p) - p.Consume() + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } } { p.SetState(96) - p.Match(PlanParserT__0) + p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4096,18 +4407,6 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(98) - p.Match(PlanParserT__3) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(99) - p.expr(0) - } - { - p.SetState(100) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4115,24 +4414,37 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - case 22: - localctx = NewJSONContainsAnyContext(p, localctx) + case 21: + localctx = NewMatchLeastContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx + { + p.SetState(100) + p.Match(PlanParserMATCH_LEAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(101) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } { p.SetState(102) - _la = p.GetTokenStream().LA(1) - - if !(_la == PlanParserJSONContainsAny || _la == PlanParserArrayContainsAny) { - p.GetErrorHandler().RecoverInline(p) - } else { - p.GetErrorHandler().ReportMatch(p) - p.Consume() + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } } { p.SetState(103) - p.Match(PlanParserT__0) + p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4152,10 +4464,30 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(106) - p.expr(0) + p.Match(PlanParserTHRESHOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } } { p.SetState(107) + p.Match(PlanParserASSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(108) + p.Match(PlanParserIntegerConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(109) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4163,29 +4495,13 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - case 23: - localctx = NewSTEuqalsContext(p, localctx) + case 22: + localctx = NewMatchMostContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx - { - p.SetState(109) - p.Match(PlanParserSTEuqals) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(110) - p.Match(PlanParserT__0) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } { p.SetState(111) - p.Match(PlanParserIdentifier) + p.Match(PlanParserMATCH_MOST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4193,43 +4509,6 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(112) - p.Match(PlanParserT__3) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(113) - p.Match(PlanParserStringLiteral) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(114) - p.Match(PlanParserT__1) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - - case 24: - localctx = NewSTTouchesContext(p, localctx) - p.SetParserRuleContext(localctx) - _prevctx = localctx - { - p.SetState(115) - p.Match(PlanParserSTTouches) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(116) p.Match(PlanParserT__0) if p.HasError() { // Recognition error - abort rule @@ -4237,7 +4516,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(117) + p.SetState(113) p.Match(PlanParserIdentifier) if p.HasError() { // Recognition error - abort rule @@ -4245,16 +4524,44 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(118) + p.SetState(114) p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } + { + p.SetState(115) + p.expr(0) + } + { + p.SetState(116) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(117) + p.Match(PlanParserTHRESHOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(118) + p.Match(PlanParserASSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } { p.SetState(119) - p.Match(PlanParserStringLiteral) + p.Match(PlanParserIntegerConstant) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4269,21 +4576,13 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - case 25: - localctx = NewSTOverlapsContext(p, localctx) + case 23: + localctx = NewMatchExactContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx - { - p.SetState(121) - p.Match(PlanParserSTOverlaps) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } { p.SetState(122) - p.Match(PlanParserT__0) + p.Match(PlanParserMATCH_EXACT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4291,7 +4590,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(123) - p.Match(PlanParserIdentifier) + p.Match(PlanParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4299,7 +4598,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(124) - p.Match(PlanParserT__3) + p.Match(PlanParserIdentifier) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4307,7 +4606,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(125) - p.Match(PlanParserStringLiteral) + p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4315,6 +4614,117 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(126) + p.expr(0) + } + { + p.SetState(127) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(128) + p.Match(PlanParserTHRESHOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(129) + p.Match(PlanParserASSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(130) + p.Match(PlanParserIntegerConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(131) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + localctx = NewUnaryContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(133) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*UnaryContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&52778168745984) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*UnaryContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(134) + p.expr(30) + } + + case 25: + localctx = NewJSONContainsContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(135) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlanParserJSONContains || _la == PlanParserArrayContains) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(136) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(137) + p.expr(0) + } + { + p.SetState(138) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(139) + p.expr(0) + } + { + p.SetState(140) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4323,19 +4733,22 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } case 26: - localctx = NewSTCrossesContext(p, localctx) + localctx = NewJSONContainsAllContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { - p.SetState(127) - p.Match(PlanParserSTCrosses) - if p.HasError() { - // Recognition error - abort rule - goto errorExit + p.SetState(142) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlanParserJSONContainsAll || _la == PlanParserArrayContainsAll) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() } } { - p.SetState(128) + p.SetState(143) p.Match(PlanParserT__0) if p.HasError() { // Recognition error - abort rule @@ -4343,15 +4756,11 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(129) - p.Match(PlanParserIdentifier) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + p.SetState(144) + p.expr(0) } { - p.SetState(130) + p.SetState(145) p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule @@ -4359,15 +4768,11 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(131) - p.Match(PlanParserStringLiteral) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + p.SetState(146) + p.expr(0) } { - p.SetState(132) + p.SetState(147) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4376,19 +4781,22 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } case 27: - localctx = NewSTContainsContext(p, localctx) + localctx = NewJSONContainsAnyContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { - p.SetState(133) - p.Match(PlanParserSTContains) - if p.HasError() { - // Recognition error - abort rule - goto errorExit + p.SetState(149) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlanParserJSONContainsAny || _la == PlanParserArrayContainsAny) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() } } { - p.SetState(134) + p.SetState(150) p.Match(PlanParserT__0) if p.HasError() { // Recognition error - abort rule @@ -4396,15 +4804,11 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(135) - p.Match(PlanParserIdentifier) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + p.SetState(151) + p.expr(0) } { - p.SetState(136) + p.SetState(152) p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule @@ -4412,15 +4816,11 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(137) - p.Match(PlanParserStringLiteral) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + p.SetState(153) + p.expr(0) } { - p.SetState(138) + p.SetState(154) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4429,19 +4829,19 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } case 28: - localctx = NewSTIntersectsContext(p, localctx) + localctx = NewSTEuqalsContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { - p.SetState(139) - p.Match(PlanParserSTIntersects) + p.SetState(156) + p.Match(PlanParserSTEuqals) if p.HasError() { // Recognition error - abort rule goto errorExit } } { - p.SetState(140) + p.SetState(157) p.Match(PlanParserT__0) if p.HasError() { // Recognition error - abort rule @@ -4449,7 +4849,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(141) + p.SetState(158) p.Match(PlanParserIdentifier) if p.HasError() { // Recognition error - abort rule @@ -4457,7 +4857,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(142) + p.SetState(159) p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule @@ -4465,7 +4865,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(143) + p.SetState(160) p.Match(PlanParserStringLiteral) if p.HasError() { // Recognition error - abort rule @@ -4473,7 +4873,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(144) + p.SetState(161) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4482,146 +4882,12 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } case 29: - localctx = NewSTWithinContext(p, localctx) + localctx = NewSTTouchesContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx - { - p.SetState(145) - p.Match(PlanParserSTWithin) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(146) - p.Match(PlanParserT__0) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(147) - p.Match(PlanParserIdentifier) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(148) - p.Match(PlanParserT__3) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(149) - p.Match(PlanParserStringLiteral) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(150) - p.Match(PlanParserT__1) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - - case 30: - localctx = NewSTDWithinContext(p, localctx) - p.SetParserRuleContext(localctx) - _prevctx = localctx - { - p.SetState(151) - p.Match(PlanParserSTDWithin) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(152) - p.Match(PlanParserT__0) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(153) - p.Match(PlanParserIdentifier) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(154) - p.Match(PlanParserT__3) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(155) - p.Match(PlanParserStringLiteral) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(156) - p.Match(PlanParserT__3) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(157) - p.expr(0) - } - { - p.SetState(158) - p.Match(PlanParserT__1) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - - case 31: - localctx = NewSTIsValidContext(p, localctx) - p.SetParserRuleContext(localctx) - _prevctx = localctx - { - p.SetState(160) - p.Match(PlanParserSTIsValid) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(161) - p.Match(PlanParserT__0) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } { p.SetState(162) - p.Match(PlanParserIdentifier) + p.Match(PlanParserSTTouches) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4629,42 +4895,34 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { p.SetState(163) - p.Match(PlanParserT__1) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - - case 32: - localctx = NewArrayLengthContext(p, localctx) - p.SetParserRuleContext(localctx) - _prevctx = localctx - { - p.SetState(164) - p.Match(PlanParserArrayLength) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(165) p.Match(PlanParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit } } + { + p.SetState(164) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(165) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } { p.SetState(166) - _la = p.GetTokenStream().LA(1) - - if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) { - p.GetErrorHandler().RecoverInline(p) - } else { - p.GetErrorHandler().ReportMatch(p) - p.Consume() + p.Match(PlanParserStringLiteral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } } { @@ -4676,13 +4934,13 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - case 33: - localctx = NewCallContext(p, localctx) + case 30: + localctx = NewSTOverlapsContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { p.SetState(168) - p.Match(PlanParserIdentifier) + p.Match(PlanParserSTOverlaps) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -4696,19 +4954,426 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { goto errorExit } } - p.SetState(181) + { + p.SetState(170) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(171) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(172) + p.Match(PlanParserStringLiteral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(173) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + localctx = NewSTCrossesContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(174) + p.Match(PlanParserSTCrosses) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(175) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(176) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(177) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(178) + p.Match(PlanParserStringLiteral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(179) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + localctx = NewSTContainsContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(180) + p.Match(PlanParserSTContains) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(181) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(182) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(183) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(184) + p.Match(PlanParserStringLiteral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(185) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + localctx = NewSTIntersectsContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(186) + p.Match(PlanParserSTIntersects) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(187) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(188) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(189) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(190) + p.Match(PlanParserStringLiteral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(191) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + localctx = NewSTWithinContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(192) + p.Match(PlanParserSTWithin) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(193) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(194) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(195) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(196) + p.Match(PlanParserStringLiteral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(197) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + localctx = NewSTDWithinContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(198) + p.Match(PlanParserSTDWithin) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(199) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(200) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(201) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(202) + p.Match(PlanParserStringLiteral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(203) + p.Match(PlanParserT__3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(204) + p.expr(0) + } + { + p.SetState(205) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + localctx = NewSTIsValidContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(207) + p.Match(PlanParserSTIsValid) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(208) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(209) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(210) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + localctx = NewArrayLengthContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(211) + p.Match(PlanParserArrayLength) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(212) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(213) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(214) + p.Match(PlanParserT__1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + localctx = NewCallContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(215) + p.Match(PlanParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(216) + p.Match(PlanParserT__0) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(228) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) - if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-1374362828726) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&7) != 0) { + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-87959269310390) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&511) != 0) { { - p.SetState(170) + p.SetState(217) p.expr(0) } - p.SetState(175) + p.SetState(222) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4720,7 +5385,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { - p.SetState(171) + p.SetState(218) p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule @@ -4728,12 +5393,12 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(172) + p.SetState(219) p.expr(0) } } - p.SetState(177) + p.SetState(224) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4743,7 +5408,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { goto errorExit } } - p.SetState(179) + p.SetState(226) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4752,7 +5417,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { if _la == PlanParserT__3 { { - p.SetState(178) + p.SetState(225) p.Match(PlanParserT__3) if p.HasError() { // Recognition error - abort rule @@ -4764,7 +5429,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { - p.SetState(183) + p.SetState(230) p.Match(PlanParserT__1) if p.HasError() { // Recognition error - abort rule @@ -4772,12 +5437,12 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - case 34: + case 39: localctx = NewIsNullContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { - p.SetState(184) + p.SetState(231) _la = p.GetTokenStream().LA(1) if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) { @@ -4788,7 +5453,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(185) + p.SetState(232) p.Match(PlanParserISNULL) if p.HasError() { // Recognition error - abort rule @@ -4796,12 +5461,12 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - case 35: + case 40: localctx = NewIsNotNullContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { - p.SetState(186) + p.SetState(233) _la = p.GetTokenStream().LA(1) if !(_la == PlanParserIdentifier || _la == PlanParserJSONIdentifier) { @@ -4812,7 +5477,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(187) + p.SetState(234) p.Match(PlanParserISNOTNULL) if p.HasError() { // Recognition error - abort rule @@ -4824,7 +5489,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { goto errorExit } p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) - p.SetState(244) + p.SetState(291) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4839,7 +5504,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { p.TriggerExitRuleEvent() } _prevctx = localctx - p.SetState(242) + p.SetState(289) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4849,14 +5514,14 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { case 1: localctx = NewPowerContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(190) + p.SetState(237) if !(p.Precpred(p.GetParserRuleContext(), 31)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 31)", "")) goto errorExit } { - p.SetState(191) + p.SetState(238) p.Match(PlanParserPOW) if p.HasError() { // Recognition error - abort rule @@ -4864,21 +5529,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(192) + p.SetState(239) p.expr(32) } case 2: localctx = NewMulDivModContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(193) + p.SetState(240) if !(p.Precpred(p.GetParserRuleContext(), 29)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 29)", "")) goto errorExit } { - p.SetState(194) + p.SetState(241) var _lt = p.GetTokenStream().LT(1) @@ -4886,7 +5551,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { _la = p.GetTokenStream().LA(1) - if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&234881024) != 0) { + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&15032385536) != 0) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*MulDivModContext).op = _ri @@ -4896,21 +5561,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(195) + p.SetState(242) p.expr(30) } case 3: localctx = NewAddSubContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(196) + p.SetState(243) if !(p.Precpred(p.GetParserRuleContext(), 28)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 28)", "")) goto errorExit } { - p.SetState(197) + p.SetState(244) var _lt = p.GetTokenStream().LT(1) @@ -4928,21 +5593,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(198) + p.SetState(245) p.expr(29) } case 4: localctx = NewShiftContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(199) + p.SetState(246) if !(p.Precpred(p.GetParserRuleContext(), 27)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 27)", "")) goto errorExit } { - p.SetState(200) + p.SetState(247) var _lt = p.GetTokenStream().LT(1) @@ -4960,20 +5625,20 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(201) + p.SetState(248) p.expr(28) } case 5: localctx = NewTermContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(202) + p.SetState(249) if !(p.Precpred(p.GetParserRuleContext(), 26)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", "")) goto errorExit } - p.SetState(204) + p.SetState(251) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4982,7 +5647,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { if _la == PlanParserNOT { { - p.SetState(203) + p.SetState(250) var _m = p.Match(PlanParserNOT) @@ -4995,7 +5660,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } { - p.SetState(206) + p.SetState(253) p.Match(PlanParserIN) if p.HasError() { // Recognition error - abort rule @@ -5003,21 +5668,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(207) + p.SetState(254) p.expr(27) } case 6: localctx = NewRangeContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(208) + p.SetState(255) if !(p.Precpred(p.GetParserRuleContext(), 11)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", "")) goto errorExit } { - p.SetState(209) + p.SetState(256) var _lt = p.GetTokenStream().LT(1) @@ -5035,10 +5700,10 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(210) + p.SetState(257) _la = p.GetTokenStream().LA(1) - if !((int64((_la-62)) & ^0x3f) == 0 && ((int64(1)<<(_la-62))&25) != 0) { + if !((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&25) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -5046,7 +5711,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(211) + p.SetState(258) var _lt = p.GetTokenStream().LT(1) @@ -5064,21 +5729,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(212) + p.SetState(259) p.expr(12) } case 7: localctx = NewReverseRangeContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(213) + p.SetState(260) if !(p.Precpred(p.GetParserRuleContext(), 10)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", "")) goto errorExit } { - p.SetState(214) + p.SetState(261) var _lt = p.GetTokenStream().LT(1) @@ -5096,10 +5761,10 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(215) + p.SetState(262) _la = p.GetTokenStream().LA(1) - if !((int64((_la-62)) & ^0x3f) == 0 && ((int64(1)<<(_la-62))&25) != 0) { + if !((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&25) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -5107,7 +5772,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(216) + p.SetState(263) var _lt = p.GetTokenStream().LT(1) @@ -5125,21 +5790,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(217) + p.SetState(264) p.expr(11) } case 8: localctx = NewRelationalContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(218) + p.SetState(265) if !(p.Precpred(p.GetParserRuleContext(), 9)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", "")) goto errorExit } { - p.SetState(219) + p.SetState(266) var _lt = p.GetTokenStream().LT(1) @@ -5157,21 +5822,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(220) + p.SetState(267) p.expr(10) } case 9: localctx = NewEqualityContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(221) + p.SetState(268) if !(p.Precpred(p.GetParserRuleContext(), 8)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) goto errorExit } { - p.SetState(222) + p.SetState(269) var _lt = p.GetTokenStream().LT(1) @@ -5189,21 +5854,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(223) + p.SetState(270) p.expr(9) } case 10: localctx = NewBitAndContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(224) + p.SetState(271) if !(p.Precpred(p.GetParserRuleContext(), 7)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) goto errorExit } { - p.SetState(225) + p.SetState(272) p.Match(PlanParserBAND) if p.HasError() { // Recognition error - abort rule @@ -5211,21 +5876,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(226) + p.SetState(273) p.expr(8) } case 11: localctx = NewBitXorContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(227) + p.SetState(274) if !(p.Precpred(p.GetParserRuleContext(), 6)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) goto errorExit } { - p.SetState(228) + p.SetState(275) p.Match(PlanParserBXOR) if p.HasError() { // Recognition error - abort rule @@ -5233,21 +5898,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(229) + p.SetState(276) p.expr(7) } case 12: localctx = NewBitOrContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(230) + p.SetState(277) if !(p.Precpred(p.GetParserRuleContext(), 5)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) goto errorExit } { - p.SetState(231) + p.SetState(278) p.Match(PlanParserBOR) if p.HasError() { // Recognition error - abort rule @@ -5255,21 +5920,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(232) + p.SetState(279) p.expr(6) } case 13: localctx = NewLogicalAndContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(233) + p.SetState(280) if !(p.Precpred(p.GetParserRuleContext(), 4)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) goto errorExit } { - p.SetState(234) + p.SetState(281) p.Match(PlanParserAND) if p.HasError() { // Recognition error - abort rule @@ -5277,21 +5942,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(235) + p.SetState(282) p.expr(5) } case 14: localctx = NewLogicalOrContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(236) + p.SetState(283) if !(p.Precpred(p.GetParserRuleContext(), 3)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) goto errorExit } { - p.SetState(237) + p.SetState(284) p.Match(PlanParserOR) if p.HasError() { // Recognition error - abort rule @@ -5299,21 +5964,21 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(238) + p.SetState(285) p.expr(4) } case 15: localctx = NewLikeContext(p, NewExprContext(p, _parentctx, _parentState)) p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr) - p.SetState(239) + p.SetState(286) - if !(p.Precpred(p.GetParserRuleContext(), 36)) { - p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 36)", "")) + if !(p.Precpred(p.GetParserRuleContext(), 41)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 41)", "")) goto errorExit } { - p.SetState(240) + p.SetState(287) p.Match(PlanParserLIKE) if p.HasError() { // Recognition error - abort rule @@ -5321,7 +5986,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } { - p.SetState(241) + p.SetState(288) p.Match(PlanParserStringLiteral) if p.HasError() { // Recognition error - abort rule @@ -5334,7 +5999,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) { } } - p.SetState(246) + p.SetState(293) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5441,7 +6106,7 @@ func (p *PlanParser) TextMatchOption() (localctx ITextMatchOptionContext) { p.EnterRule(localctx, 2, PlanParserRULE_textMatchOption) p.EnterOuterAlt(localctx, 1) { - p.SetState(247) + p.SetState(294) p.Match(PlanParserMINIMUM_SHOULD_MATCH) if p.HasError() { // Recognition error - abort rule @@ -5449,7 +6114,7 @@ func (p *PlanParser) TextMatchOption() (localctx ITextMatchOptionContext) { } } { - p.SetState(248) + p.SetState(295) p.Match(PlanParserASSIGN) if p.HasError() { // Recognition error - abort rule @@ -5457,7 +6122,7 @@ func (p *PlanParser) TextMatchOption() (localctx ITextMatchOptionContext) { } } { - p.SetState(249) + p.SetState(296) p.Match(PlanParserIntegerConstant) if p.HasError() { // Recognition error - abort rule @@ -5537,7 +6202,7 @@ func (p *PlanParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) boo return p.Precpred(p.GetParserRuleContext(), 3) case 14: - return p.Precpred(p.GetParserRuleContext(), 36) + return p.Precpred(p.GetParserRuleContext(), 41) default: panic("No predicate with index: " + fmt.Sprint(predIndex)) diff --git a/internal/parser/planparserv2/generated/plan_visitor.go b/internal/parser/planparserv2/generated/plan_visitor.go index d841bd99d5..4e0d763a8f 100644 --- a/internal/parser/planparserv2/generated/plan_visitor.go +++ b/internal/parser/planparserv2/generated/plan_visitor.go @@ -10,6 +10,9 @@ type PlanVisitor interface { // Visit a parse tree produced by PlanParser#String. VisitString(ctx *StringContext) interface{} + // Visit a parse tree produced by PlanParser#MatchAny. + VisitMatchAny(ctx *MatchAnyContext) interface{} + // Visit a parse tree produced by PlanParser#Floating. VisitFloating(ctx *FloatingContext) interface{} @@ -46,6 +49,9 @@ type PlanVisitor interface { // Visit a parse tree produced by PlanParser#PhraseMatch. VisitPhraseMatch(ctx *PhraseMatchContext) interface{} + // Visit a parse tree produced by PlanParser#MatchLeast. + VisitMatchLeast(ctx *MatchLeastContext) interface{} + // Visit a parse tree produced by PlanParser#ArrayLength. VisitArrayLength(ctx *ArrayLengthContext) interface{} @@ -64,6 +70,9 @@ type PlanVisitor interface { // Visit a parse tree produced by PlanParser#Range. VisitRange(ctx *RangeContext) interface{} + // Visit a parse tree produced by PlanParser#MatchAll. + VisitMatchAll(ctx *MatchAllContext) interface{} + // Visit a parse tree produced by PlanParser#STIsValid. VisitSTIsValid(ctx *STIsValidContext) interface{} @@ -79,6 +88,9 @@ type PlanVisitor interface { // Visit a parse tree produced by PlanParser#STOverlaps. VisitSTOverlaps(ctx *STOverlapsContext) interface{} + // Visit a parse tree produced by PlanParser#MatchMost. + VisitMatchMost(ctx *MatchMostContext) interface{} + // Visit a parse tree produced by PlanParser#JSONIdentifier. VisitJSONIdentifier(ctx *JSONIdentifierContext) interface{} @@ -88,6 +100,9 @@ type PlanVisitor interface { // Visit a parse tree produced by PlanParser#Parens. VisitParens(ctx *ParensContext) interface{} + // Visit a parse tree produced by PlanParser#MatchExact. + VisitMatchExact(ctx *MatchExactContext) interface{} + // Visit a parse tree produced by PlanParser#JSONContainsAll. VisitJSONContainsAll(ctx *JSONContainsAllContext) interface{} diff --git a/internal/parser/planparserv2/parser_visitor.go b/internal/parser/planparserv2/parser_visitor.go index ac93953263..8ac764732e 100644 --- a/internal/parser/planparserv2/parser_visitor.go +++ b/internal/parser/planparserv2/parser_visitor.go @@ -192,7 +192,7 @@ func (v *ParserVisitor) VisitString(ctx *parser.StringContext) interface{} { } func checkDirectComparisonBinaryField(columnInfo *planpb.ColumnInfo) error { - if typeutil.IsArrayType(columnInfo.GetDataType()) && len(columnInfo.GetNestedPath()) == 0 { + if typeutil.IsArrayType(columnInfo.GetDataType()) && len(columnInfo.GetNestedPath()) == 0 && !columnInfo.GetIsElementLevel() { return errors.New("can not comparisons array fields directly") } return nil @@ -664,6 +664,10 @@ func isElementFilterExpr(expr *ExprWithType) bool { return expr.expr.GetElementFilterExpr() != nil } +func isMatchExpr(expr *ExprWithType) bool { + return expr.expr.GetMatchExpr() != nil +} + const EPSILON = 1e-10 func (v *ParserVisitor) VisitRandomSample(ctx *parser.RandomSampleContext) interface{} { @@ -715,7 +719,10 @@ func (v *ParserVisitor) VisitTerm(ctx *parser.TermContext) interface{} { } dataType := columnInfo.GetDataType() - if typeutil.IsArrayType(dataType) && len(columnInfo.GetNestedPath()) != 0 { + // Use element type for IN operation in two cases: + // 1. Array with nested path (e.g., arr[0] IN [1, 2, 3]) + // 2. Array with element level flag (e.g., $[intField] IN [1, 2] in MATCH_ALL/ElementFilter) + if typeutil.IsArrayType(dataType) && (len(columnInfo.GetNestedPath()) != 0 || columnInfo.GetIsElementLevel()) { dataType = columnInfo.GetElementType() } @@ -2298,9 +2305,9 @@ func (v *ParserVisitor) VisitStructSubField(ctx *parser.StructSubFieldContext) i // Remove "$[" prefix and "]" suffix fieldName := tokenText[2 : len(tokenText)-1] - // Check if we're inside an ElementFilter context + // Check if we're inside an ElementFilter or MATCH_* context if v.currentStructArrayField == "" { - return fmt.Errorf("$[%s] syntax can only be used inside ElementFilter", fieldName) + return fmt.Errorf("$[%s] syntax can only be used inside ElementFilter or MATCH_*", fieldName) } // Construct full field name for struct array field @@ -2311,7 +2318,7 @@ func (v *ParserVisitor) VisitStructSubField(ctx *parser.StructSubFieldContext) i return fmt.Errorf("array field not found: %s, error: %s", fullFieldName, err) } - // In element-level context, data_type should be the element type + // In element-level context, use Array as storage type, element type for operations elementType := field.GetElementType() return &ExprWithType{ @@ -2320,12 +2327,12 @@ func (v *ParserVisitor) VisitStructSubField(ctx *parser.StructSubFieldContext) i ColumnExpr: &planpb.ColumnExpr{ Info: &planpb.ColumnInfo{ FieldId: field.FieldID, - DataType: elementType, // Use element type, not storage type + DataType: schemapb.DataType_Array, // Storage type is Array IsPrimaryKey: field.IsPrimaryKey, IsAutoID: field.AutoID, IsPartitionKey: field.IsPartitionKey, IsClusteringKey: field.IsClusteringKey, - ElementType: elementType, + ElementType: elementType, // Element type for operations Nullable: field.GetNullable(), IsElementLevel: true, // Mark as element-level access }, @@ -2336,3 +2343,113 @@ func (v *ParserVisitor) VisitStructSubField(ctx *parser.StructSubFieldContext) i nodeDependent: true, } } + +// parseMatchExpr is a helper function for parsing match expressions +// matchType: the type of match operation (MatchAll, MatchAny, MatchLeast, MatchMost) +// count: for MatchLeast/MatchMost, the count parameter (N); for MatchAll/MatchAny, this is ignored (0) +func (v *ParserVisitor) parseMatchExpr(structArrayFieldName string, exprCtx parser.IExprContext, matchType planpb.MatchType, count int64, funcName string) interface{} { + // Check for nested match expression - not allowed + if v.currentStructArrayField != "" { + return fmt.Errorf("nested %s is not supported, already inside match expression for field: %s", funcName, v.currentStructArrayField) + } + + // Set current context for element expression parsing + v.currentStructArrayField = structArrayFieldName + defer func() { v.currentStructArrayField = "" }() + + // Parse the predicate expression + predicate := exprCtx.Accept(v) + if err := getError(predicate); err != nil { + return fmt.Errorf("cannot parse predicate expression: %s, error: %s", exprCtx.GetText(), err) + } + + predicateExpr := getExpr(predicate) + if predicateExpr == nil { + return fmt.Errorf("invalid predicate expression in %s: %s", funcName, exprCtx.GetText()) + } + + // Build MatchExpr proto + return &ExprWithType{ + expr: &planpb.Expr{ + Expr: &planpb.Expr_MatchExpr{ + MatchExpr: &planpb.MatchExpr{ + StructName: structArrayFieldName, + Predicate: predicateExpr.expr, + MatchType: matchType, + Count: count, + }, + }, + }, + dataType: schemapb.DataType_Bool, + } +} + +// VisitMatchAll handles MATCH_ALL expressions +// Syntax: MATCH_ALL(structArrayField, $[intField] == 1 && $[strField] == "aaa") +// All elements must match the predicate +func (v *ParserVisitor) VisitMatchAll(ctx *parser.MatchAllContext) interface{} { + structArrayFieldName := ctx.Identifier().GetText() + return v.parseMatchExpr(structArrayFieldName, ctx.Expr(), planpb.MatchType_MatchAll, 0, "MATCH_ALL") +} + +// VisitMatchAny handles MATCH_ANY expressions +// Syntax: MATCH_ANY(structArrayField, $[intField] == 1 && $[strField] == "aaa") +// At least one element must match the predicate +func (v *ParserVisitor) VisitMatchAny(ctx *parser.MatchAnyContext) interface{} { + structArrayFieldName := ctx.Identifier().GetText() + return v.parseMatchExpr(structArrayFieldName, ctx.Expr(), planpb.MatchType_MatchAny, 0, "MATCH_ANY") +} + +// VisitMatchLeast handles MATCH_LEAST expressions +// Syntax: MATCH_LEAST(structArrayField, $[intField] == 1 && $[strField] == "aaa", threshold=N) +// At least N elements must match the predicate +func (v *ParserVisitor) VisitMatchLeast(ctx *parser.MatchLeastContext) interface{} { + structArrayFieldName := ctx.Identifier().GetText() + + countStr := ctx.IntegerConstant().GetText() + count, err := strconv.ParseInt(countStr, 10, 64) + if err != nil { + return fmt.Errorf("invalid count in MATCH_LEAST: %s", countStr) + } + if count <= 0 { + return fmt.Errorf("count in MATCH_LEAST must be positive, got: %d", count) + } + + return v.parseMatchExpr(structArrayFieldName, ctx.Expr(), planpb.MatchType_MatchLeast, count, "MATCH_LEAST") +} + +// VisitMatchMost handles MATCH_MOST expressions +// Syntax: MATCH_MOST(structArrayField, $[intField] == 1 && $[strField] == "aaa", threshold=N) +// At most N elements must match the predicate +func (v *ParserVisitor) VisitMatchMost(ctx *parser.MatchMostContext) interface{} { + structArrayFieldName := ctx.Identifier().GetText() + + countStr := ctx.IntegerConstant().GetText() + count, err := strconv.ParseInt(countStr, 10, 64) + if err != nil { + return fmt.Errorf("invalid count in MATCH_MOST: %s", countStr) + } + if count < 0 { + return fmt.Errorf("count in MATCH_MOST cannot be negative, got: %d", count) + } + + return v.parseMatchExpr(structArrayFieldName, ctx.Expr(), planpb.MatchType_MatchMost, count, "MATCH_MOST") +} + +// VisitMatchExact handles MATCH_EXACT expressions +// Syntax: MATCH_EXACT(structArrayField, $[intField] == 1 && $[strField] == "aaa", threshold=N) +// Exactly N elements must match the predicate +func (v *ParserVisitor) VisitMatchExact(ctx *parser.MatchExactContext) interface{} { + structArrayFieldName := ctx.Identifier().GetText() + + countStr := ctx.IntegerConstant().GetText() + count, err := strconv.ParseInt(countStr, 10, 64) + if err != nil { + return fmt.Errorf("invalid count in MATCH_EXACT: %s", countStr) + } + if count < 0 { + return fmt.Errorf("count in MATCH_EXACT cannot be negative, got: %d", count) + } + + return v.parseMatchExpr(structArrayFieldName, ctx.Expr(), planpb.MatchType_MatchExact, count, "MATCH_EXACT") +} diff --git a/internal/parser/planparserv2/plan_parser_v2_test.go b/internal/parser/planparserv2/plan_parser_v2_test.go index 0166b01073..99ea7d426e 100644 --- a/internal/parser/planparserv2/plan_parser_v2_test.go +++ b/internal/parser/planparserv2/plan_parser_v2_test.go @@ -2557,3 +2557,150 @@ func TestExpr_ElementFilter(t *testing.T) { assertInvalidExpr(t, helper, expr) } } + +func TestExpr_Match(t *testing.T) { + schema := newTestSchema(true) + helper, err := typeutil.CreateSchemaHelper(schema) + assert.NoError(t, err) + + // Valid MATCH_ALL expressions + validExprs := []string{ + // MATCH_ALL: all elements must match + `MATCH_ALL(struct_array, $[sub_int] > 1)`, + `MATCH_ALL(struct_array, $[sub_int] == 100)`, + `MATCH_ALL(struct_array, $[sub_str] == "aaa")`, + `MATCH_ALL(struct_array, $[sub_str] == "aaa" && $[sub_int] > 100)`, + `MATCH_ALL(struct_array, $[sub_str] != "" || $[sub_int] >= 0)`, + + // MATCH_ANY: at least one element must match + `MATCH_ANY(struct_array, $[sub_int] > 1)`, + `MATCH_ANY(struct_array, $[sub_int] == 100)`, + `MATCH_ANY(struct_array, $[sub_str] == "aaa")`, + `MATCH_ANY(struct_array, $[sub_str] == "aaa" && $[sub_int] > 100)`, + + // MATCH_LEAST: at least N elements must match + `MATCH_LEAST(struct_array, $[sub_int] > 1, threshold=3)`, + `MATCH_LEAST(struct_array, $[sub_str] == "aaa", threshold=1)`, + `MATCH_LEAST(struct_array, $[sub_str] == "aaa" && $[sub_int] > 100, threshold=2)`, + + // MATCH_MOST: at most N elements must match + `MATCH_MOST(struct_array, $[sub_int] > 1, threshold=3)`, + `MATCH_MOST(struct_array, $[sub_str] == "aaa", threshold=0)`, + `MATCH_MOST(struct_array, $[sub_str] == "aaa" && $[sub_int] > 100, threshold=5)`, + + // MATCH_EXACT: exactly N elements must match + `MATCH_EXACT(struct_array, $[sub_int] > 1, threshold=2)`, + `MATCH_EXACT(struct_array, $[sub_str] == "aaa", threshold=0)`, + `MATCH_EXACT(struct_array, $[sub_str] == "aaa" && $[sub_int] > 100, threshold=3)`, + + // Combined with other expressions (match must be last) + `Int64Field > 0 && MATCH_ALL(struct_array, $[sub_int] > 1)`, + `Int64Field > 0 && MATCH_ANY(struct_array, $[sub_str] == "test")`, + `Int64Field > 0 && MATCH_LEAST(struct_array, $[sub_int] > 1, threshold=2)`, + + // Complex predicates + `MATCH_ALL(struct_array, ($[sub_int] > 0 && $[sub_int] < 100) || $[sub_str] == "default")`, + `MATCH_ANY(struct_array, !($[sub_int] < 0))`, + + // Case insensitivity + `match_all(struct_array, $[sub_int] > 1)`, + `match_any(struct_array, $[sub_int] > 1)`, + `match_least(struct_array, $[sub_int] > 1, threshold=2)`, + `match_most(struct_array, $[sub_int] > 1, threshold=2)`, + `match_exact(struct_array, $[sub_int] > 1, threshold=2)`, + + // Multiple match expressions with logical operators + `MATCH_ALL(struct_array, $[sub_int] > 1) || MATCH_ANY(struct_array, $[sub_str] == "test")`, + `MATCH_ALL(struct_array, $[sub_int] > 1) && MATCH_ANY(struct_array, $[sub_str] == "test")`, + `MATCH_ANY(struct_array, $[sub_int] > 1) || Int64Field > 0`, + `MATCH_ALL(struct_array, $[sub_int] > 1) && Int64Field > 0`, + } + + for _, expr := range validExprs { + assertValidExpr(t, helper, expr) + } + + // Test proto structure assertions + t.Run("MatchAll_Proto", func(t *testing.T) { + expr, err := ParseExpr(helper, `MATCH_ALL(struct_array, $[sub_int] > 1)`, nil) + assert.NoError(t, err) + assert.NotNil(t, expr.GetMatchExpr()) + assert.Equal(t, "struct_array", expr.GetMatchExpr().GetStructName()) + assert.Equal(t, planpb.MatchType_MatchAll, expr.GetMatchExpr().GetMatchType()) + assert.Equal(t, int64(0), expr.GetMatchExpr().GetCount()) + }) + + t.Run("MatchAny_Proto", func(t *testing.T) { + expr, err := ParseExpr(helper, `MATCH_ANY(struct_array, $[sub_str] == "aaa")`, nil) + assert.NoError(t, err) + assert.NotNil(t, expr.GetMatchExpr()) + assert.Equal(t, "struct_array", expr.GetMatchExpr().GetStructName()) + assert.Equal(t, planpb.MatchType_MatchAny, expr.GetMatchExpr().GetMatchType()) + assert.Equal(t, int64(0), expr.GetMatchExpr().GetCount()) + }) + + t.Run("MatchLeast_Proto", func(t *testing.T) { + expr, err := ParseExpr(helper, `MATCH_LEAST(struct_array, $[sub_int] > 1, threshold=3)`, nil) + assert.NoError(t, err) + assert.NotNil(t, expr.GetMatchExpr()) + assert.Equal(t, "struct_array", expr.GetMatchExpr().GetStructName()) + assert.Equal(t, planpb.MatchType_MatchLeast, expr.GetMatchExpr().GetMatchType()) + assert.Equal(t, int64(3), expr.GetMatchExpr().GetCount()) + }) + + t.Run("MatchMost_Proto", func(t *testing.T) { + expr, err := ParseExpr(helper, `MATCH_MOST(struct_array, $[sub_str] == "aaa", threshold=5)`, nil) + assert.NoError(t, err) + assert.NotNil(t, expr.GetMatchExpr()) + assert.Equal(t, "struct_array", expr.GetMatchExpr().GetStructName()) + assert.Equal(t, planpb.MatchType_MatchMost, expr.GetMatchExpr().GetMatchType()) + assert.Equal(t, int64(5), expr.GetMatchExpr().GetCount()) + }) + + t.Run("MatchExact_Proto", func(t *testing.T) { + expr, err := ParseExpr(helper, `MATCH_EXACT(struct_array, $[sub_int] == 100, threshold=2)`, nil) + assert.NoError(t, err) + assert.NotNil(t, expr.GetMatchExpr()) + assert.Equal(t, "struct_array", expr.GetMatchExpr().GetStructName()) + assert.Equal(t, planpb.MatchType_MatchExact, expr.GetMatchExpr().GetMatchType()) + assert.Equal(t, int64(2), expr.GetMatchExpr().GetCount()) + }) + + // Invalid expressions + invalidExprs := []string{ + // Nested match expressions not allowed + `MATCH_ALL(struct_array, MATCH_ANY(struct_array, $[sub_int] > 1))`, + `MATCH_ANY(struct_array, $[sub_int] > 1 && MATCH_ALL(struct_array, $[sub_str] == "1"))`, + + // $[field] syntax outside match context + `$[sub_int] > 1`, + `Int64Field > 0 && $[sub_int] > 1`, + + // Non-existent fields + `MATCH_ALL(struct_array, $[non_existent_field] > 1)`, + `MATCH_ALL(non_existent_array, $[sub_int] > 1)`, + + // Missing parameters + `MATCH_ALL(struct_array)`, + `MATCH_ALL()`, + `MATCH_ANY(struct_array)`, + `MATCH_ANY()`, + `MATCH_LEAST(struct_array, $[sub_int] > 1)`, // missing count + `MATCH_MOST(struct_array, $[sub_int] > 1)`, // missing count + `MATCH_EXACT(struct_array, $[sub_int] > 1)`, // missing count + + // MATCH_ALL/MATCH_ANY should not have count parameter + `MATCH_ALL(struct_array, $[sub_int] > 1, 3)`, + `MATCH_ANY(struct_array, $[sub_int] > 1, 2)`, + + // Invalid count values + `MATCH_LEAST(struct_array, $[sub_int] > 1, threshold=0)`, // count must be positive for MATCH_LEAST + `MATCH_LEAST(struct_array, $[sub_int] > 1, threshold=-1)`, // negative count + `MATCH_MOST(struct_array, $[sub_int] > 1, threshold=-1)`, // negative count + `MATCH_EXACT(struct_array, $[sub_int] > 1, threshold=-1)`, // negative count + } + + for _, expr := range invalidExprs { + assertInvalidExpr(t, helper, expr) + } +} diff --git a/internal/parser/planparserv2/utils.go b/internal/parser/planparserv2/utils.go index 7c38da27f3..656b492569 100644 --- a/internal/parser/planparserv2/utils.go +++ b/internal/parser/planparserv2/utils.go @@ -362,8 +362,14 @@ func handleBinaryArithExpr(op planpb.OpType, arithExpr *planpb.BinaryArithExpr, func handleCompareRightValue(op planpb.OpType, left *ExprWithType, right *planpb.ValueExpr) (*planpb.Expr, error) { dataType := left.dataType - if typeutil.IsArrayType(dataType) && len(toColumnInfo(left).GetNestedPath()) != 0 { - dataType = toColumnInfo(left).GetElementType() + columnInfo := toColumnInfo(left) + + // Use element type for casting in two cases: + // 1. Array with nested path (e.g., arr[0]) + // 2. Array with element level flag (e.g., $[intField] in MATCH_ALL/ElementFilter) + if typeutil.IsArrayType(dataType) && columnInfo != nil && + (len(columnInfo.GetNestedPath()) != 0 || columnInfo.GetIsElementLevel()) { + dataType = columnInfo.GetElementType() } if !left.expr.GetIsTemplate() && !isTemplateExpr(right) { @@ -378,7 +384,6 @@ func handleCompareRightValue(op planpb.OpType, left *ExprWithType, right *planpb return handleBinaryArithExpr(op, leftArithExpr, left.dataType, right) } - columnInfo := toColumnInfo(left) if columnInfo == nil { return nil, errors.New("not supported to combine multiple fields") } diff --git a/pkg/proto/plan.proto b/pkg/proto/plan.proto index 149f1cfe3e..d4e6da9765 100644 --- a/pkg/proto/plan.proto +++ b/pkg/proto/plan.proto @@ -252,6 +252,22 @@ message ElementFilterExpr { Expr predicate = 3; } +// MatchType defines the type of match operation for struct array queries +enum MatchType { + MatchAll = 0; // All elements must match the predicate + MatchAny = 1; // At least one element matches the predicate + MatchLeast = 2; // At least N elements match the predicate + MatchMost = 3; // At most N elements match the predicate + MatchExact = 4; // Exactly N elements match the predicate +} + +message MatchExpr { + string struct_name = 1; // The struct array field name (e.g., struct_array) + Expr predicate = 2; // The condition expression using $[field] syntax (e.g., $[intField] == 1 && $[strField] == "aaa") + MatchType match_type = 3; // Type of match operation + int64 count = 4; // For MatchLeast/MatchMost: the count parameter (N) +} + message AlwaysTrueExpr {} message Interval { @@ -293,6 +309,7 @@ message Expr { GISFunctionFilterExpr gisfunction_filter_expr = 17; TimestamptzArithCompareExpr timestamptz_arith_compare_expr = 18; ElementFilterExpr element_filter_expr = 19; + MatchExpr match_expr = 21; }; bool is_template = 20; } diff --git a/pkg/proto/planpb/plan.pb.go b/pkg/proto/planpb/plan.pb.go index 7a0bd16e7e..fcb4d07bbe 100644 --- a/pkg/proto/planpb/plan.pb.go +++ b/pkg/proto/planpb/plan.pb.go @@ -244,6 +244,62 @@ func (VectorType) EnumDescriptor() ([]byte, []int) { return file_plan_proto_rawDescGZIP(), []int{2} } +// MatchType defines the type of match operation for struct array queries +type MatchType int32 + +const ( + MatchType_MatchAll MatchType = 0 // All elements must match the predicate + MatchType_MatchAny MatchType = 1 // At least one element matches the predicate + MatchType_MatchLeast MatchType = 2 // At least N elements match the predicate + MatchType_MatchMost MatchType = 3 // At most N elements match the predicate + MatchType_MatchExact MatchType = 4 // Exactly N elements match the predicate +) + +// Enum value maps for MatchType. +var ( + MatchType_name = map[int32]string{ + 0: "MatchAll", + 1: "MatchAny", + 2: "MatchLeast", + 3: "MatchMost", + 4: "MatchExact", + } + MatchType_value = map[string]int32{ + "MatchAll": 0, + "MatchAny": 1, + "MatchLeast": 2, + "MatchMost": 3, + "MatchExact": 4, + } +) + +func (x MatchType) Enum() *MatchType { + p := new(MatchType) + *p = x + return p +} + +func (x MatchType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (MatchType) Descriptor() protoreflect.EnumDescriptor { + return file_plan_proto_enumTypes[3].Descriptor() +} + +func (MatchType) Type() protoreflect.EnumType { + return &file_plan_proto_enumTypes[3] +} + +func (x MatchType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use MatchType.Descriptor instead. +func (MatchType) EnumDescriptor() ([]byte, []int) { + return file_plan_proto_rawDescGZIP(), []int{3} +} + type FunctionType int32 const ( @@ -274,11 +330,11 @@ func (x FunctionType) String() string { } func (FunctionType) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[3].Descriptor() + return file_plan_proto_enumTypes[4].Descriptor() } func (FunctionType) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[3] + return &file_plan_proto_enumTypes[4] } func (x FunctionType) Number() protoreflect.EnumNumber { @@ -287,7 +343,7 @@ func (x FunctionType) Number() protoreflect.EnumNumber { // Deprecated: Use FunctionType.Descriptor instead. func (FunctionType) EnumDescriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{3} + return file_plan_proto_rawDescGZIP(), []int{4} } // FunctionMode decide how to calculate boost score @@ -322,11 +378,11 @@ func (x FunctionMode) String() string { } func (FunctionMode) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[4].Descriptor() + return file_plan_proto_enumTypes[5].Descriptor() } func (FunctionMode) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[4] + return &file_plan_proto_enumTypes[5] } func (x FunctionMode) Number() protoreflect.EnumNumber { @@ -335,7 +391,7 @@ func (x FunctionMode) Number() protoreflect.EnumNumber { // Deprecated: Use FunctionMode.Descriptor instead. func (FunctionMode) EnumDescriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{4} + return file_plan_proto_rawDescGZIP(), []int{5} } // BoostMode decide how to calculate final score @@ -370,11 +426,11 @@ func (x BoostMode) String() string { } func (BoostMode) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[5].Descriptor() + return file_plan_proto_enumTypes[6].Descriptor() } func (BoostMode) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[5] + return &file_plan_proto_enumTypes[6] } func (x BoostMode) Number() protoreflect.EnumNumber { @@ -383,7 +439,7 @@ func (x BoostMode) Number() protoreflect.EnumNumber { // Deprecated: Use BoostMode.Descriptor instead. func (BoostMode) EnumDescriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{5} + return file_plan_proto_rawDescGZIP(), []int{6} } // 0: invalid @@ -426,11 +482,11 @@ func (x JSONContainsExpr_JSONOp) String() string { } func (JSONContainsExpr_JSONOp) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[6].Descriptor() + return file_plan_proto_enumTypes[7].Descriptor() } func (JSONContainsExpr_JSONOp) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[6] + return &file_plan_proto_enumTypes[7] } func (x JSONContainsExpr_JSONOp) Number() protoreflect.EnumNumber { @@ -475,11 +531,11 @@ func (x NullExpr_NullOp) String() string { } func (NullExpr_NullOp) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[7].Descriptor() + return file_plan_proto_enumTypes[8].Descriptor() } func (NullExpr_NullOp) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[7] + return &file_plan_proto_enumTypes[8] } func (x NullExpr_NullOp) Number() protoreflect.EnumNumber { @@ -547,11 +603,11 @@ func (x GISFunctionFilterExpr_GISOp) String() string { } func (GISFunctionFilterExpr_GISOp) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[8].Descriptor() + return file_plan_proto_enumTypes[9].Descriptor() } func (GISFunctionFilterExpr_GISOp) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[8] + return &file_plan_proto_enumTypes[9] } func (x GISFunctionFilterExpr_GISOp) Number() protoreflect.EnumNumber { @@ -593,11 +649,11 @@ func (x UnaryExpr_UnaryOp) String() string { } func (UnaryExpr_UnaryOp) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[9].Descriptor() + return file_plan_proto_enumTypes[10].Descriptor() } func (UnaryExpr_UnaryOp) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[9] + return &file_plan_proto_enumTypes[10] } func (x UnaryExpr_UnaryOp) Number() protoreflect.EnumNumber { @@ -642,11 +698,11 @@ func (x BinaryExpr_BinaryOp) String() string { } func (BinaryExpr_BinaryOp) Descriptor() protoreflect.EnumDescriptor { - return file_plan_proto_enumTypes[10].Descriptor() + return file_plan_proto_enumTypes[11].Descriptor() } func (BinaryExpr_BinaryOp) Type() protoreflect.EnumType { - return &file_plan_proto_enumTypes[10] + return &file_plan_proto_enumTypes[11] } func (x BinaryExpr_BinaryOp) Number() protoreflect.EnumNumber { @@ -2359,6 +2415,77 @@ func (x *ElementFilterExpr) GetPredicate() *Expr { return nil } +type MatchExpr struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StructName string `protobuf:"bytes,1,opt,name=struct_name,json=structName,proto3" json:"struct_name,omitempty"` // The struct array field name (e.g., struct_array) + Predicate *Expr `protobuf:"bytes,2,opt,name=predicate,proto3" json:"predicate,omitempty"` // The condition expression using $[field] syntax (e.g., $[intField] == 1 && $[strField] == "aaa") + MatchType MatchType `protobuf:"varint,3,opt,name=match_type,json=matchType,proto3,enum=milvus.proto.plan.MatchType" json:"match_type,omitempty"` // Type of match operation + Count int64 `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"` // For MatchLeast/MatchMost: the count parameter (N) +} + +func (x *MatchExpr) Reset() { + *x = MatchExpr{} + if protoimpl.UnsafeEnabled { + mi := &file_plan_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MatchExpr) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MatchExpr) ProtoMessage() {} + +func (x *MatchExpr) ProtoReflect() protoreflect.Message { + mi := &file_plan_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MatchExpr.ProtoReflect.Descriptor instead. +func (*MatchExpr) Descriptor() ([]byte, []int) { + return file_plan_proto_rawDescGZIP(), []int{23} +} + +func (x *MatchExpr) GetStructName() string { + if x != nil { + return x.StructName + } + return "" +} + +func (x *MatchExpr) GetPredicate() *Expr { + if x != nil { + return x.Predicate + } + return nil +} + +func (x *MatchExpr) GetMatchType() MatchType { + if x != nil { + return x.MatchType + } + return MatchType_MatchAll +} + +func (x *MatchExpr) GetCount() int64 { + if x != nil { + return x.Count + } + return 0 +} + type AlwaysTrueExpr struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -2368,7 +2495,7 @@ type AlwaysTrueExpr struct { func (x *AlwaysTrueExpr) Reset() { *x = AlwaysTrueExpr{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[23] + mi := &file_plan_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2381,7 +2508,7 @@ func (x *AlwaysTrueExpr) String() string { func (*AlwaysTrueExpr) ProtoMessage() {} func (x *AlwaysTrueExpr) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[23] + mi := &file_plan_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2394,7 +2521,7 @@ func (x *AlwaysTrueExpr) ProtoReflect() protoreflect.Message { // Deprecated: Use AlwaysTrueExpr.ProtoReflect.Descriptor instead. func (*AlwaysTrueExpr) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{23} + return file_plan_proto_rawDescGZIP(), []int{24} } type Interval struct { @@ -2413,7 +2540,7 @@ type Interval struct { func (x *Interval) Reset() { *x = Interval{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[24] + mi := &file_plan_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2426,7 +2553,7 @@ func (x *Interval) String() string { func (*Interval) ProtoMessage() {} func (x *Interval) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[24] + mi := &file_plan_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2439,7 +2566,7 @@ func (x *Interval) ProtoReflect() protoreflect.Message { // Deprecated: Use Interval.ProtoReflect.Descriptor instead. func (*Interval) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{24} + return file_plan_proto_rawDescGZIP(), []int{25} } func (x *Interval) GetYears() int64 { @@ -2500,7 +2627,7 @@ type TimestamptzArithCompareExpr struct { func (x *TimestamptzArithCompareExpr) Reset() { *x = TimestamptzArithCompareExpr{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[25] + mi := &file_plan_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2513,7 +2640,7 @@ func (x *TimestamptzArithCompareExpr) String() string { func (*TimestamptzArithCompareExpr) ProtoMessage() {} func (x *TimestamptzArithCompareExpr) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[25] + mi := &file_plan_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2526,7 +2653,7 @@ func (x *TimestamptzArithCompareExpr) ProtoReflect() protoreflect.Message { // Deprecated: Use TimestamptzArithCompareExpr.ProtoReflect.Descriptor instead. func (*TimestamptzArithCompareExpr) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{25} + return file_plan_proto_rawDescGZIP(), []int{26} } func (x *TimestamptzArithCompareExpr) GetTimestamptzColumn() *ColumnInfo { @@ -2590,6 +2717,7 @@ type Expr struct { // *Expr_GisfunctionFilterExpr // *Expr_TimestamptzArithCompareExpr // *Expr_ElementFilterExpr + // *Expr_MatchExpr Expr isExpr_Expr `protobuf_oneof:"expr"` IsTemplate bool `protobuf:"varint,20,opt,name=is_template,json=isTemplate,proto3" json:"is_template,omitempty"` } @@ -2597,7 +2725,7 @@ type Expr struct { func (x *Expr) Reset() { *x = Expr{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[26] + mi := &file_plan_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2610,7 +2738,7 @@ func (x *Expr) String() string { func (*Expr) ProtoMessage() {} func (x *Expr) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[26] + mi := &file_plan_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2623,7 +2751,7 @@ func (x *Expr) ProtoReflect() protoreflect.Message { // Deprecated: Use Expr.ProtoReflect.Descriptor instead. func (*Expr) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{26} + return file_plan_proto_rawDescGZIP(), []int{27} } func (m *Expr) GetExpr() isExpr_Expr { @@ -2766,6 +2894,13 @@ func (x *Expr) GetElementFilterExpr() *ElementFilterExpr { return nil } +func (x *Expr) GetMatchExpr() *MatchExpr { + if x, ok := x.GetExpr().(*Expr_MatchExpr); ok { + return x.MatchExpr + } + return nil +} + func (x *Expr) GetIsTemplate() bool { if x != nil { return x.IsTemplate @@ -2853,6 +2988,10 @@ type Expr_ElementFilterExpr struct { ElementFilterExpr *ElementFilterExpr `protobuf:"bytes,19,opt,name=element_filter_expr,json=elementFilterExpr,proto3,oneof"` } +type Expr_MatchExpr struct { + MatchExpr *MatchExpr `protobuf:"bytes,21,opt,name=match_expr,json=matchExpr,proto3,oneof"` +} + func (*Expr_TermExpr) isExpr_Expr() {} func (*Expr_UnaryExpr) isExpr_Expr() {} @@ -2891,6 +3030,8 @@ func (*Expr_TimestamptzArithCompareExpr) isExpr_Expr() {} func (*Expr_ElementFilterExpr) isExpr_Expr() {} +func (*Expr_MatchExpr) isExpr_Expr() {} + type VectorANNS struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -2906,7 +3047,7 @@ type VectorANNS struct { func (x *VectorANNS) Reset() { *x = VectorANNS{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[27] + mi := &file_plan_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2919,7 +3060,7 @@ func (x *VectorANNS) String() string { func (*VectorANNS) ProtoMessage() {} func (x *VectorANNS) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[27] + mi := &file_plan_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2932,7 +3073,7 @@ func (x *VectorANNS) ProtoReflect() protoreflect.Message { // Deprecated: Use VectorANNS.ProtoReflect.Descriptor instead. func (*VectorANNS) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{27} + return file_plan_proto_rawDescGZIP(), []int{28} } func (x *VectorANNS) GetVectorType() VectorType { @@ -2983,7 +3124,7 @@ type QueryPlanNode struct { func (x *QueryPlanNode) Reset() { *x = QueryPlanNode{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[28] + mi := &file_plan_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2996,7 +3137,7 @@ func (x *QueryPlanNode) String() string { func (*QueryPlanNode) ProtoMessage() {} func (x *QueryPlanNode) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[28] + mi := &file_plan_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3009,7 +3150,7 @@ func (x *QueryPlanNode) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryPlanNode.ProtoReflect.Descriptor instead. func (*QueryPlanNode) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{28} + return file_plan_proto_rawDescGZIP(), []int{29} } func (x *QueryPlanNode) GetPredicates() *Expr { @@ -3047,7 +3188,7 @@ type ScoreFunction struct { func (x *ScoreFunction) Reset() { *x = ScoreFunction{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[29] + mi := &file_plan_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3060,7 +3201,7 @@ func (x *ScoreFunction) String() string { func (*ScoreFunction) ProtoMessage() {} func (x *ScoreFunction) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[29] + mi := &file_plan_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3073,7 +3214,7 @@ func (x *ScoreFunction) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoreFunction.ProtoReflect.Descriptor instead. func (*ScoreFunction) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{29} + return file_plan_proto_rawDescGZIP(), []int{30} } func (x *ScoreFunction) GetFilter() *Expr { @@ -3116,7 +3257,7 @@ type ScoreOption struct { func (x *ScoreOption) Reset() { *x = ScoreOption{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[30] + mi := &file_plan_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3129,7 +3270,7 @@ func (x *ScoreOption) String() string { func (*ScoreOption) ProtoMessage() {} func (x *ScoreOption) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[30] + mi := &file_plan_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3142,7 +3283,7 @@ func (x *ScoreOption) ProtoReflect() protoreflect.Message { // Deprecated: Use ScoreOption.ProtoReflect.Descriptor instead. func (*ScoreOption) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{30} + return file_plan_proto_rawDescGZIP(), []int{31} } func (x *ScoreOption) GetBoostMode() BoostMode { @@ -3170,7 +3311,7 @@ type PlanOption struct { func (x *PlanOption) Reset() { *x = PlanOption{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[31] + mi := &file_plan_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3183,7 +3324,7 @@ func (x *PlanOption) String() string { func (*PlanOption) ProtoMessage() {} func (x *PlanOption) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[31] + mi := &file_plan_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3196,7 +3337,7 @@ func (x *PlanOption) ProtoReflect() protoreflect.Message { // Deprecated: Use PlanOption.ProtoReflect.Descriptor instead. func (*PlanOption) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{31} + return file_plan_proto_rawDescGZIP(), []int{32} } func (x *PlanOption) GetExprUseJsonStats() bool { @@ -3228,7 +3369,7 @@ type PlanNode struct { func (x *PlanNode) Reset() { *x = PlanNode{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[32] + mi := &file_plan_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3241,7 +3382,7 @@ func (x *PlanNode) String() string { func (*PlanNode) ProtoMessage() {} func (x *PlanNode) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[32] + mi := &file_plan_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3254,7 +3395,7 @@ func (x *PlanNode) ProtoReflect() protoreflect.Message { // Deprecated: Use PlanNode.ProtoReflect.Descriptor instead. func (*PlanNode) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{32} + return file_plan_proto_rawDescGZIP(), []int{33} } func (m *PlanNode) GetNode() isPlanNode_Node { @@ -3699,255 +3840,276 @@ var file_plan_proto_rawDesc = []byte{ 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, - 0x09, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x22, 0x10, 0x0a, 0x0e, 0x41, 0x6c, - 0x77, 0x61, 0x79, 0x73, 0x54, 0x72, 0x75, 0x65, 0x45, 0x78, 0x70, 0x72, 0x22, 0x96, 0x01, 0x0a, - 0x08, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x79, 0x65, 0x61, - 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x79, 0x65, 0x61, 0x72, 0x73, 0x12, - 0x16, 0x0a, 0x06, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x06, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x79, 0x73, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x64, 0x61, 0x79, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x68, - 0x6f, 0x75, 0x72, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x68, 0x6f, 0x75, 0x72, - 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x07, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x73, - 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x73, 0x65, - 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0xdf, 0x02, 0x0a, 0x1b, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, - 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x41, 0x72, 0x69, 0x74, 0x68, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, - 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x4c, 0x0a, 0x12, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x74, 0x7a, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x11, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x43, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x12, 0x39, 0x0a, 0x08, 0x61, 0x72, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x70, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, - 0x70, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x61, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x12, 0x37, - 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x52, 0x08, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x38, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x61, - 0x72, 0x65, 0x5f, 0x6f, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, - 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x4f, - 0x70, 0x12, 0x44, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x5f, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x47, 0x65, 0x6e, - 0x65, 0x72, 0x69, 0x63, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x61, - 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x81, 0x0c, 0x0a, 0x04, 0x45, 0x78, 0x70, 0x72, - 0x12, 0x3a, 0x0a, 0x09, 0x74, 0x65, 0x72, 0x6d, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x54, 0x65, 0x72, 0x6d, 0x45, 0x78, 0x70, 0x72, - 0x48, 0x00, 0x52, 0x08, 0x74, 0x65, 0x72, 0x6d, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3d, 0x0a, 0x0a, - 0x75, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x55, 0x6e, 0x61, 0x72, 0x79, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, - 0x52, 0x09, 0x75, 0x6e, 0x61, 0x72, 0x79, 0x45, 0x78, 0x70, 0x72, 0x12, 0x40, 0x0a, 0x0b, 0x62, - 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x45, 0x78, 0x70, 0x72, 0x48, - 0x00, 0x52, 0x0a, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x45, 0x78, 0x70, 0x72, 0x12, 0x43, 0x0a, - 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, - 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, 0x78, - 0x70, 0x72, 0x12, 0x4d, 0x0a, 0x10, 0x75, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, - 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, + 0x09, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x22, 0xb6, 0x01, 0x0a, 0x09, 0x4d, + 0x61, 0x74, 0x63, 0x68, 0x45, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x75, + 0x63, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x09, 0x70, 0x72, 0x65, + 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, - 0x2e, 0x55, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, - 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, - 0x72, 0x12, 0x50, 0x0a, 0x11, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, - 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, - 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, - 0x48, 0x00, 0x52, 0x0f, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, - 0x78, 0x70, 0x72, 0x12, 0x74, 0x0a, 0x1f, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x61, 0x72, - 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x70, 0x5f, 0x65, 0x76, 0x61, 0x6c, 0x5f, 0x72, 0x61, 0x6e, 0x67, - 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, - 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x45, 0x76, - 0x61, 0x6c, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x1a, 0x62, - 0x69, 0x6e, 0x61, 0x72, 0x79, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x45, 0x76, 0x61, 0x6c, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x50, 0x0a, 0x11, 0x62, 0x69, 0x6e, - 0x61, 0x72, 0x79, 0x5f, 0x61, 0x72, 0x69, 0x74, 0x68, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x41, - 0x72, 0x69, 0x74, 0x68, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0f, 0x62, 0x69, 0x6e, 0x61, - 0x72, 0x79, 0x41, 0x72, 0x69, 0x74, 0x68, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3d, 0x0a, 0x0a, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, - 0x6c, 0x61, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, - 0x09, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x6f, - 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, - 0x6c, 0x61, 0x6e, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, - 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x45, 0x78, 0x70, 0x72, 0x12, 0x40, 0x0a, 0x0b, - 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, 0x69, 0x73, 0x74, 0x73, 0x45, 0x78, 0x70, 0x72, - 0x48, 0x00, 0x52, 0x0a, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x45, 0x78, 0x70, 0x72, 0x12, 0x4d, - 0x0a, 0x10, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x5f, 0x74, 0x72, 0x75, 0x65, 0x5f, 0x65, 0x78, - 0x70, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x41, 0x6c, 0x77, - 0x61, 0x79, 0x73, 0x54, 0x72, 0x75, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0e, 0x61, - 0x6c, 0x77, 0x61, 0x79, 0x73, 0x54, 0x72, 0x75, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x53, 0x0a, - 0x12, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x5f, 0x65, - 0x78, 0x70, 0x72, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x4a, 0x53, - 0x4f, 0x4e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, - 0x52, 0x10, 0x6a, 0x73, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x45, 0x78, - 0x70, 0x72, 0x12, 0x3a, 0x0a, 0x09, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, - 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x43, 0x61, 0x6c, 0x6c, 0x45, 0x78, - 0x70, 0x72, 0x48, 0x00, 0x52, 0x08, 0x63, 0x61, 0x6c, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3a, - 0x0a, 0x09, 0x6e, 0x75, 0x6c, 0x6c, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x4e, 0x75, 0x6c, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, - 0x52, 0x08, 0x6e, 0x75, 0x6c, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x12, 0x53, 0x0a, 0x12, 0x72, 0x61, - 0x6e, 0x64, 0x6f, 0x6d, 0x5f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, - 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x6f, - 0x6d, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x10, 0x72, - 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, - 0x62, 0x0a, 0x17, 0x67, 0x69, 0x73, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, - 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x47, 0x49, 0x53, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x15, 0x67, 0x69, - 0x73, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, - 0x78, 0x70, 0x72, 0x12, 0x75, 0x0a, 0x1e, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, - 0x74, 0x7a, 0x5f, 0x61, 0x72, 0x69, 0x74, 0x68, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, - 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, - 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x41, 0x72, 0x69, 0x74, 0x68, - 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x1b, 0x74, - 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x41, 0x72, 0x69, 0x74, 0x68, 0x43, - 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x56, 0x0a, 0x13, 0x65, 0x6c, - 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x78, 0x70, - 0x72, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x6c, 0x65, 0x6d, - 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, - 0x11, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x78, - 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, - 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x54, 0x65, 0x6d, 0x70, 0x6c, - 0x61, 0x74, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, 0x22, 0x86, 0x02, 0x0a, 0x0a, - 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x4e, 0x4e, 0x53, 0x12, 0x3e, 0x0a, 0x0b, 0x76, 0x65, - 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, - 0x6c, 0x61, 0x6e, 0x2e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, - 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, - 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, - 0x65, 0x6c, 0x64, 0x49, 0x64, 0x12, 0x37, 0x0a, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, - 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, - 0x70, 0x72, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x12, 0x3b, - 0x0a, 0x0a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x09, 0x71, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x27, 0x0a, 0x0f, 0x70, - 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, - 0x72, 0x54, 0x61, 0x67, 0x22, 0x79, 0x0a, 0x0d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6c, 0x61, - 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x37, 0x0a, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, - 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, - 0x70, 0x72, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x12, 0x19, - 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x07, 0x69, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, - 0xc8, 0x01, 0x0a, 0x0d, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x12, 0x2f, 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x74, - 0x65, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x02, 0x52, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x33, 0x0a, 0x04, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x46, 0x75, 0x6e, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, - 0x39, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, - 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, - 0x69, 0x72, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x90, 0x01, 0x0a, 0x0b, 0x53, - 0x63, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x0a, 0x62, 0x6f, - 0x6f, 0x73, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, + 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x09, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x12, 0x3b, 0x0a, 0x0a, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x09, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x22, 0x10, 0x0a, 0x0e, 0x41, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x54, 0x72, 0x75, + 0x65, 0x45, 0x78, 0x70, 0x72, 0x22, 0x96, 0x01, 0x0a, 0x08, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, + 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x79, 0x65, 0x61, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x05, 0x79, 0x65, 0x61, 0x72, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x6f, 0x6e, 0x74, + 0x68, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x73, + 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x79, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, + 0x64, 0x61, 0x79, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x68, 0x6f, 0x75, 0x72, 0x73, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x05, 0x68, 0x6f, 0x75, 0x72, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x69, + 0x6e, 0x75, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x69, 0x6e, + 0x75, 0x74, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0xdf, + 0x02, 0x0a, 0x1b, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x41, 0x72, + 0x69, 0x74, 0x68, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x4c, + 0x0a, 0x12, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x5f, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x43, + 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x11, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x39, 0x0a, 0x08, + 0x61, 0x72, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, - 0x61, 0x6e, 0x2e, 0x42, 0x6f, 0x6f, 0x73, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x09, 0x62, 0x6f, - 0x6f, 0x73, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x44, 0x0a, 0x0d, 0x66, 0x75, 0x6e, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, - 0x61, 0x6e, 0x2e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x52, - 0x0c, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x3b, 0x0a, - 0x0a, 0x50, 0x6c, 0x61, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x13, 0x65, - 0x78, 0x70, 0x72, 0x5f, 0x75, 0x73, 0x65, 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, - 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x65, 0x78, 0x70, 0x72, 0x55, 0x73, - 0x65, 0x4a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0x8c, 0x04, 0x0a, 0x08, 0x50, - 0x6c, 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x76, 0x65, 0x63, 0x74, 0x6f, - 0x72, 0x5f, 0x61, 0x6e, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, + 0x61, 0x6e, 0x2e, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, + 0x61, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x12, 0x37, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x49, 0x6e, + 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, + 0x12, 0x38, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x5f, 0x6f, 0x70, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x4f, 0x70, 0x12, 0x44, 0x0a, 0x0d, 0x63, 0x6f, + 0x6d, 0x70, 0x61, 0x72, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x52, 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x22, 0xc0, 0x0c, 0x0a, 0x04, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3a, 0x0a, 0x09, 0x74, 0x65, 0x72, + 0x6d, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, - 0x2e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x4e, 0x4e, 0x53, 0x48, 0x00, 0x52, 0x0a, 0x76, - 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x6e, 0x6e, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x70, 0x72, 0x65, - 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x2e, 0x54, 0x65, 0x72, 0x6d, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x08, 0x74, 0x65, 0x72, + 0x6d, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3d, 0x0a, 0x0a, 0x75, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x65, + 0x78, 0x70, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x55, 0x6e, + 0x61, 0x72, 0x79, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x09, 0x75, 0x6e, 0x61, 0x72, 0x79, + 0x45, 0x78, 0x70, 0x72, 0x12, 0x40, 0x0a, 0x0b, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x65, + 0x78, 0x70, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x42, 0x69, + 0x6e, 0x61, 0x72, 0x79, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0a, 0x62, 0x69, 0x6e, 0x61, + 0x72, 0x79, 0x45, 0x78, 0x70, 0x72, 0x12, 0x43, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, + 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, + 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0b, + 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x4d, 0x0a, 0x10, 0x75, + 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x55, 0x6e, 0x61, 0x72, 0x79, 0x52, + 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0e, 0x75, 0x6e, 0x61, 0x72, + 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x50, 0x0a, 0x11, 0x62, 0x69, + 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0f, 0x62, 0x69, 0x6e, + 0x61, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x74, 0x0a, 0x1f, + 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x61, 0x72, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x70, 0x5f, + 0x65, 0x76, 0x61, 0x6c, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, + 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x45, 0x76, 0x61, 0x6c, 0x52, 0x61, 0x6e, 0x67, 0x65, + 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x1a, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x41, 0x72, + 0x69, 0x74, 0x68, 0x4f, 0x70, 0x45, 0x76, 0x61, 0x6c, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x78, + 0x70, 0x72, 0x12, 0x50, 0x0a, 0x11, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x61, 0x72, 0x69, + 0x74, 0x68, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, - 0x6e, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, - 0x61, 0x74, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6c, 0x61, - 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x28, - 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, - 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, - 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x64, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x64, 0x79, 0x6e, 0x61, - 0x6d, 0x69, 0x63, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x0d, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, - 0x3a, 0x0a, 0x07, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x07, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x72, 0x73, 0x12, 0x40, 0x0a, 0x0c, 0x70, - 0x6c, 0x61, 0x6e, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x50, 0x6c, 0x61, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x0b, 0x70, 0x6c, 0x61, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x0a, - 0x0c, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x21, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x88, 0x01, 0x01, 0x42, 0x06, 0x0a, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, - 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2a, 0xea, 0x01, 0x0a, 0x06, 0x4f, 0x70, - 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, - 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e, - 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x47, 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, - 0x61, 0x6c, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x4c, 0x65, 0x73, 0x73, 0x54, 0x68, 0x61, 0x6e, - 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x4c, 0x65, 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, - 0x04, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, - 0x4e, 0x6f, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x06, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x72, - 0x65, 0x66, 0x69, 0x78, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x07, 0x12, 0x10, 0x0a, 0x0c, 0x50, - 0x6f, 0x73, 0x74, 0x66, 0x69, 0x78, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x08, 0x12, 0x09, 0x0a, - 0x05, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x09, 0x12, 0x09, 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, - 0x65, 0x10, 0x0a, 0x12, 0x06, 0x0a, 0x02, 0x49, 0x6e, 0x10, 0x0b, 0x12, 0x09, 0x0a, 0x05, 0x4e, - 0x6f, 0x74, 0x49, 0x6e, 0x10, 0x0c, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x65, 0x78, 0x74, 0x4d, 0x61, - 0x74, 0x63, 0x68, 0x10, 0x0d, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x68, 0x72, 0x61, 0x73, 0x65, 0x4d, - 0x61, 0x74, 0x63, 0x68, 0x10, 0x0e, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x4d, - 0x61, 0x74, 0x63, 0x68, 0x10, 0x0f, 0x2a, 0x58, 0x0a, 0x0b, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, - 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, - 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x64, 0x64, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x53, - 0x75, 0x62, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x4d, 0x75, 0x6c, 0x10, 0x03, 0x12, 0x07, 0x0a, - 0x03, 0x44, 0x69, 0x76, 0x10, 0x04, 0x12, 0x07, 0x0a, 0x03, 0x4d, 0x6f, 0x64, 0x10, 0x05, 0x12, - 0x0f, 0x0a, 0x0b, 0x41, 0x72, 0x72, 0x61, 0x79, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0x06, - 0x2a, 0xfa, 0x01, 0x0a, 0x0a, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x10, 0x0a, 0x0c, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, - 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, - 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, - 0x74, 0x6f, 0x72, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x42, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, - 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x03, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x70, 0x61, - 0x72, 0x73, 0x65, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x04, - 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x38, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x05, - 0x12, 0x16, 0x0a, 0x12, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, - 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x06, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x6d, 0x62, 0x4c, - 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, - 0x10, 0x07, 0x12, 0x19, 0x0a, 0x15, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x46, 0x6c, - 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x08, 0x12, 0x15, 0x0a, - 0x11, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x38, 0x56, 0x65, 0x63, 0x74, - 0x6f, 0x72, 0x10, 0x09, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x42, - 0x69, 0x6e, 0x61, 0x72, 0x79, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x0a, 0x2a, 0x3e, 0x0a, + 0x6e, 0x2e, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x41, 0x72, 0x69, 0x74, 0x68, 0x45, 0x78, 0x70, + 0x72, 0x48, 0x00, 0x52, 0x0f, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x41, 0x72, 0x69, 0x74, 0x68, + 0x45, 0x78, 0x70, 0x72, 0x12, 0x3d, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x65, 0x78, + 0x70, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x45, + 0x78, 0x70, 0x72, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x65, 0x78, + 0x70, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x43, 0x6f, 0x6c, + 0x75, 0x6d, 0x6e, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, + 0x6e, 0x45, 0x78, 0x70, 0x72, 0x12, 0x40, 0x0a, 0x0b, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x5f, + 0x65, 0x78, 0x70, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, + 0x78, 0x69, 0x73, 0x74, 0x73, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0a, 0x65, 0x78, 0x69, + 0x73, 0x74, 0x73, 0x45, 0x78, 0x70, 0x72, 0x12, 0x4d, 0x0a, 0x10, 0x61, 0x6c, 0x77, 0x61, 0x79, + 0x73, 0x5f, 0x74, 0x72, 0x75, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x41, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x54, 0x72, 0x75, 0x65, + 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0e, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x54, 0x72, + 0x75, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x53, 0x0a, 0x12, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x0d, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x4a, 0x53, 0x4f, 0x4e, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x10, 0x6a, 0x73, 0x6f, 0x6e, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3a, 0x0a, 0x09, 0x63, + 0x61, 0x6c, 0x6c, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, + 0x61, 0x6e, 0x2e, 0x43, 0x61, 0x6c, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x08, 0x63, + 0x61, 0x6c, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3a, 0x0a, 0x09, 0x6e, 0x75, 0x6c, 0x6c, 0x5f, + 0x65, 0x78, 0x70, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x4e, + 0x75, 0x6c, 0x6c, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x08, 0x6e, 0x75, 0x6c, 0x6c, 0x45, + 0x78, 0x70, 0x72, 0x12, 0x53, 0x0a, 0x12, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x5f, 0x73, 0x61, + 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, + 0x6c, 0x61, 0x6e, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x10, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x61, + 0x6d, 0x70, 0x6c, 0x65, 0x45, 0x78, 0x70, 0x72, 0x12, 0x62, 0x0a, 0x17, 0x67, 0x69, 0x73, 0x66, + 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x65, + 0x78, 0x70, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x47, 0x49, + 0x53, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, + 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x15, 0x67, 0x69, 0x73, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x78, 0x70, 0x72, 0x12, 0x75, 0x0a, 0x1e, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x74, 0x7a, 0x5f, 0x61, 0x72, 0x69, 0x74, + 0x68, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x12, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x74, 0x7a, 0x41, 0x72, 0x69, 0x74, 0x68, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, + 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x1b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x74, 0x7a, 0x41, 0x72, 0x69, 0x74, 0x68, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x45, + 0x78, 0x70, 0x72, 0x12, 0x56, 0x0a, 0x13, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x66, + 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6c, 0x74, + 0x65, 0x72, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x11, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x78, 0x70, 0x72, 0x12, 0x3d, 0x0a, 0x0a, 0x6d, + 0x61, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, + 0x6c, 0x61, 0x6e, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, + 0x09, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x45, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, + 0x5f, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0a, 0x69, 0x73, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x65, + 0x78, 0x70, 0x72, 0x22, 0x86, 0x02, 0x0a, 0x0a, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x4e, + 0x4e, 0x53, 0x12, 0x3e, 0x0a, 0x0b, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x56, 0x65, 0x63, 0x74, + 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x64, 0x12, 0x37, 0x0a, + 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x09, 0x71, 0x75, 0x65, 0x72, 0x79, 0x49, + 0x6e, 0x66, 0x6f, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, + 0x65, 0x72, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x6c, + 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x54, 0x61, 0x67, 0x22, 0x79, 0x0a, 0x0d, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6c, 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x37, 0x0a, + 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0xc8, 0x01, 0x0a, 0x0d, 0x53, 0x63, 0x6f, 0x72, + 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x06, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, + 0x70, 0x72, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x06, 0x77, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x12, 0x33, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4b, 0x65, + 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x22, 0x90, 0x01, 0x0a, 0x0b, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x0a, 0x62, 0x6f, 0x6f, 0x73, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x42, 0x6f, 0x6f, 0x73, 0x74, + 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x09, 0x62, 0x6f, 0x6f, 0x73, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x12, + 0x44, 0x0a, 0x0d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x6f, 0x64, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x46, 0x75, 0x6e, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x0c, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x3b, 0x0a, 0x0a, 0x50, 0x6c, 0x61, 0x6e, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x13, 0x65, 0x78, 0x70, 0x72, 0x5f, 0x75, 0x73, 0x65, 0x5f, + 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x10, 0x65, 0x78, 0x70, 0x72, 0x55, 0x73, 0x65, 0x4a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x73, 0x22, 0x8c, 0x04, 0x0a, 0x08, 0x50, 0x6c, 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x12, + 0x40, 0x0a, 0x0b, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x6e, 0x6e, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, + 0x4e, 0x4e, 0x53, 0x48, 0x00, 0x52, 0x0a, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x6e, 0x6e, + 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, + 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x05, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6c, 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, + 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, + 0x52, 0x0e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x64, 0x73, + 0x12, 0x25, 0x0a, 0x0e, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, + 0x63, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, 0x3a, 0x0a, 0x07, 0x73, 0x63, 0x6f, 0x72, 0x65, + 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x53, 0x63, 0x6f, + 0x72, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x73, 0x63, 0x6f, 0x72, + 0x65, 0x72, 0x73, 0x12, 0x40, 0x0a, 0x0c, 0x70, 0x6c, 0x61, 0x6e, 0x5f, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x50, 0x6c, + 0x61, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x70, 0x6c, 0x61, 0x6e, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x0a, 0x0c, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x5f, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, + 0x53, 0x63, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x73, 0x63, 0x6f, + 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x09, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x88, 0x01, 0x01, 0x42, 0x06, 0x0a, 0x04, 0x6e, + 0x6f, 0x64, 0x65, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x2a, 0xea, 0x01, 0x0a, 0x06, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, + 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x47, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x47, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, + 0x4c, 0x65, 0x73, 0x73, 0x54, 0x68, 0x61, 0x6e, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x4c, 0x65, + 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x04, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x71, 0x75, + 0x61, 0x6c, 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6c, + 0x10, 0x06, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x4d, 0x61, 0x74, 0x63, + 0x68, 0x10, 0x07, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x6f, 0x73, 0x74, 0x66, 0x69, 0x78, 0x4d, 0x61, + 0x74, 0x63, 0x68, 0x10, 0x08, 0x12, 0x09, 0x0a, 0x05, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x09, + 0x12, 0x09, 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x10, 0x0a, 0x12, 0x06, 0x0a, 0x02, 0x49, + 0x6e, 0x10, 0x0b, 0x12, 0x09, 0x0a, 0x05, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x10, 0x0c, 0x12, 0x0d, + 0x0a, 0x09, 0x54, 0x65, 0x78, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0d, 0x12, 0x0f, 0x0a, + 0x0b, 0x50, 0x68, 0x72, 0x61, 0x73, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0e, 0x12, 0x0e, + 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0f, 0x2a, 0x58, + 0x0a, 0x0b, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, + 0x07, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x64, + 0x64, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x75, 0x62, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, + 0x4d, 0x75, 0x6c, 0x10, 0x03, 0x12, 0x07, 0x0a, 0x03, 0x44, 0x69, 0x76, 0x10, 0x04, 0x12, 0x07, + 0x0a, 0x03, 0x4d, 0x6f, 0x64, 0x10, 0x05, 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0x06, 0x2a, 0xfa, 0x01, 0x0a, 0x0a, 0x56, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x42, 0x69, 0x6e, 0x61, 0x72, + 0x79, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, + 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x46, 0x6c, + 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x02, 0x12, 0x12, 0x0a, + 0x0e, 0x42, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, + 0x03, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x70, 0x61, 0x72, 0x73, 0x65, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x38, + 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x05, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x6d, 0x62, 0x4c, + 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x06, + 0x12, 0x18, 0x0a, 0x14, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x07, 0x12, 0x19, 0x0a, 0x15, 0x45, 0x6d, + 0x62, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, + 0x49, 0x6e, 0x74, 0x38, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x09, 0x12, 0x17, 0x0a, 0x13, + 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x56, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x10, 0x0a, 0x2a, 0x56, 0x0a, 0x09, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x41, 0x6c, 0x6c, 0x10, 0x00, + 0x12, 0x0c, 0x0a, 0x08, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x41, 0x6e, 0x79, 0x10, 0x01, 0x12, 0x0e, + 0x0a, 0x0a, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x65, 0x61, 0x73, 0x74, 0x10, 0x02, 0x12, 0x0d, + 0x0a, 0x09, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4d, 0x6f, 0x73, 0x74, 0x10, 0x03, 0x12, 0x0e, 0x0a, + 0x0a, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x45, 0x78, 0x61, 0x63, 0x74, 0x10, 0x04, 0x2a, 0x3e, 0x0a, 0x0c, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x12, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, @@ -3977,150 +4139,155 @@ func file_plan_proto_rawDescGZIP() []byte { return file_plan_proto_rawDescData } -var file_plan_proto_enumTypes = make([]protoimpl.EnumInfo, 11) -var file_plan_proto_msgTypes = make([]protoimpl.MessageInfo, 33) +var file_plan_proto_enumTypes = make([]protoimpl.EnumInfo, 12) +var file_plan_proto_msgTypes = make([]protoimpl.MessageInfo, 34) var file_plan_proto_goTypes = []interface{}{ (OpType)(0), // 0: milvus.proto.plan.OpType (ArithOpType)(0), // 1: milvus.proto.plan.ArithOpType (VectorType)(0), // 2: milvus.proto.plan.VectorType - (FunctionType)(0), // 3: milvus.proto.plan.FunctionType - (FunctionMode)(0), // 4: milvus.proto.plan.FunctionMode - (BoostMode)(0), // 5: milvus.proto.plan.BoostMode - (JSONContainsExpr_JSONOp)(0), // 6: milvus.proto.plan.JSONContainsExpr.JSONOp - (NullExpr_NullOp)(0), // 7: milvus.proto.plan.NullExpr.NullOp - (GISFunctionFilterExpr_GISOp)(0), // 8: milvus.proto.plan.GISFunctionFilterExpr.GISOp - (UnaryExpr_UnaryOp)(0), // 9: milvus.proto.plan.UnaryExpr.UnaryOp - (BinaryExpr_BinaryOp)(0), // 10: milvus.proto.plan.BinaryExpr.BinaryOp - (*GenericValue)(nil), // 11: milvus.proto.plan.GenericValue - (*Array)(nil), // 12: milvus.proto.plan.Array - (*SearchIteratorV2Info)(nil), // 13: milvus.proto.plan.SearchIteratorV2Info - (*QueryInfo)(nil), // 14: milvus.proto.plan.QueryInfo - (*ColumnInfo)(nil), // 15: milvus.proto.plan.ColumnInfo - (*ColumnExpr)(nil), // 16: milvus.proto.plan.ColumnExpr - (*ExistsExpr)(nil), // 17: milvus.proto.plan.ExistsExpr - (*ValueExpr)(nil), // 18: milvus.proto.plan.ValueExpr - (*UnaryRangeExpr)(nil), // 19: milvus.proto.plan.UnaryRangeExpr - (*BinaryRangeExpr)(nil), // 20: milvus.proto.plan.BinaryRangeExpr - (*CallExpr)(nil), // 21: milvus.proto.plan.CallExpr - (*CompareExpr)(nil), // 22: milvus.proto.plan.CompareExpr - (*TermExpr)(nil), // 23: milvus.proto.plan.TermExpr - (*JSONContainsExpr)(nil), // 24: milvus.proto.plan.JSONContainsExpr - (*NullExpr)(nil), // 25: milvus.proto.plan.NullExpr - (*GISFunctionFilterExpr)(nil), // 26: milvus.proto.plan.GISFunctionFilterExpr - (*UnaryExpr)(nil), // 27: milvus.proto.plan.UnaryExpr - (*BinaryExpr)(nil), // 28: milvus.proto.plan.BinaryExpr - (*BinaryArithOp)(nil), // 29: milvus.proto.plan.BinaryArithOp - (*BinaryArithExpr)(nil), // 30: milvus.proto.plan.BinaryArithExpr - (*BinaryArithOpEvalRangeExpr)(nil), // 31: milvus.proto.plan.BinaryArithOpEvalRangeExpr - (*RandomSampleExpr)(nil), // 32: milvus.proto.plan.RandomSampleExpr - (*ElementFilterExpr)(nil), // 33: milvus.proto.plan.ElementFilterExpr - (*AlwaysTrueExpr)(nil), // 34: milvus.proto.plan.AlwaysTrueExpr - (*Interval)(nil), // 35: milvus.proto.plan.Interval - (*TimestamptzArithCompareExpr)(nil), // 36: milvus.proto.plan.TimestamptzArithCompareExpr - (*Expr)(nil), // 37: milvus.proto.plan.Expr - (*VectorANNS)(nil), // 38: milvus.proto.plan.VectorANNS - (*QueryPlanNode)(nil), // 39: milvus.proto.plan.QueryPlanNode - (*ScoreFunction)(nil), // 40: milvus.proto.plan.ScoreFunction - (*ScoreOption)(nil), // 41: milvus.proto.plan.ScoreOption - (*PlanOption)(nil), // 42: milvus.proto.plan.PlanOption - (*PlanNode)(nil), // 43: milvus.proto.plan.PlanNode - (schemapb.DataType)(0), // 44: milvus.proto.schema.DataType - (*commonpb.KeyValuePair)(nil), // 45: milvus.proto.common.KeyValuePair + (MatchType)(0), // 3: milvus.proto.plan.MatchType + (FunctionType)(0), // 4: milvus.proto.plan.FunctionType + (FunctionMode)(0), // 5: milvus.proto.plan.FunctionMode + (BoostMode)(0), // 6: milvus.proto.plan.BoostMode + (JSONContainsExpr_JSONOp)(0), // 7: milvus.proto.plan.JSONContainsExpr.JSONOp + (NullExpr_NullOp)(0), // 8: milvus.proto.plan.NullExpr.NullOp + (GISFunctionFilterExpr_GISOp)(0), // 9: milvus.proto.plan.GISFunctionFilterExpr.GISOp + (UnaryExpr_UnaryOp)(0), // 10: milvus.proto.plan.UnaryExpr.UnaryOp + (BinaryExpr_BinaryOp)(0), // 11: milvus.proto.plan.BinaryExpr.BinaryOp + (*GenericValue)(nil), // 12: milvus.proto.plan.GenericValue + (*Array)(nil), // 13: milvus.proto.plan.Array + (*SearchIteratorV2Info)(nil), // 14: milvus.proto.plan.SearchIteratorV2Info + (*QueryInfo)(nil), // 15: milvus.proto.plan.QueryInfo + (*ColumnInfo)(nil), // 16: milvus.proto.plan.ColumnInfo + (*ColumnExpr)(nil), // 17: milvus.proto.plan.ColumnExpr + (*ExistsExpr)(nil), // 18: milvus.proto.plan.ExistsExpr + (*ValueExpr)(nil), // 19: milvus.proto.plan.ValueExpr + (*UnaryRangeExpr)(nil), // 20: milvus.proto.plan.UnaryRangeExpr + (*BinaryRangeExpr)(nil), // 21: milvus.proto.plan.BinaryRangeExpr + (*CallExpr)(nil), // 22: milvus.proto.plan.CallExpr + (*CompareExpr)(nil), // 23: milvus.proto.plan.CompareExpr + (*TermExpr)(nil), // 24: milvus.proto.plan.TermExpr + (*JSONContainsExpr)(nil), // 25: milvus.proto.plan.JSONContainsExpr + (*NullExpr)(nil), // 26: milvus.proto.plan.NullExpr + (*GISFunctionFilterExpr)(nil), // 27: milvus.proto.plan.GISFunctionFilterExpr + (*UnaryExpr)(nil), // 28: milvus.proto.plan.UnaryExpr + (*BinaryExpr)(nil), // 29: milvus.proto.plan.BinaryExpr + (*BinaryArithOp)(nil), // 30: milvus.proto.plan.BinaryArithOp + (*BinaryArithExpr)(nil), // 31: milvus.proto.plan.BinaryArithExpr + (*BinaryArithOpEvalRangeExpr)(nil), // 32: milvus.proto.plan.BinaryArithOpEvalRangeExpr + (*RandomSampleExpr)(nil), // 33: milvus.proto.plan.RandomSampleExpr + (*ElementFilterExpr)(nil), // 34: milvus.proto.plan.ElementFilterExpr + (*MatchExpr)(nil), // 35: milvus.proto.plan.MatchExpr + (*AlwaysTrueExpr)(nil), // 36: milvus.proto.plan.AlwaysTrueExpr + (*Interval)(nil), // 37: milvus.proto.plan.Interval + (*TimestamptzArithCompareExpr)(nil), // 38: milvus.proto.plan.TimestamptzArithCompareExpr + (*Expr)(nil), // 39: milvus.proto.plan.Expr + (*VectorANNS)(nil), // 40: milvus.proto.plan.VectorANNS + (*QueryPlanNode)(nil), // 41: milvus.proto.plan.QueryPlanNode + (*ScoreFunction)(nil), // 42: milvus.proto.plan.ScoreFunction + (*ScoreOption)(nil), // 43: milvus.proto.plan.ScoreOption + (*PlanOption)(nil), // 44: milvus.proto.plan.PlanOption + (*PlanNode)(nil), // 45: milvus.proto.plan.PlanNode + (schemapb.DataType)(0), // 46: milvus.proto.schema.DataType + (*commonpb.KeyValuePair)(nil), // 47: milvus.proto.common.KeyValuePair } var file_plan_proto_depIdxs = []int32{ - 12, // 0: milvus.proto.plan.GenericValue.array_val:type_name -> milvus.proto.plan.Array - 11, // 1: milvus.proto.plan.Array.array:type_name -> milvus.proto.plan.GenericValue - 44, // 2: milvus.proto.plan.Array.element_type:type_name -> milvus.proto.schema.DataType - 13, // 3: milvus.proto.plan.QueryInfo.search_iterator_v2_info:type_name -> milvus.proto.plan.SearchIteratorV2Info - 44, // 4: milvus.proto.plan.QueryInfo.json_type:type_name -> milvus.proto.schema.DataType - 44, // 5: milvus.proto.plan.ColumnInfo.data_type:type_name -> milvus.proto.schema.DataType - 44, // 6: milvus.proto.plan.ColumnInfo.element_type:type_name -> milvus.proto.schema.DataType - 15, // 7: milvus.proto.plan.ColumnExpr.info:type_name -> milvus.proto.plan.ColumnInfo - 15, // 8: milvus.proto.plan.ExistsExpr.info:type_name -> milvus.proto.plan.ColumnInfo - 11, // 9: milvus.proto.plan.ValueExpr.value:type_name -> milvus.proto.plan.GenericValue - 15, // 10: milvus.proto.plan.UnaryRangeExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo + 13, // 0: milvus.proto.plan.GenericValue.array_val:type_name -> milvus.proto.plan.Array + 12, // 1: milvus.proto.plan.Array.array:type_name -> milvus.proto.plan.GenericValue + 46, // 2: milvus.proto.plan.Array.element_type:type_name -> milvus.proto.schema.DataType + 14, // 3: milvus.proto.plan.QueryInfo.search_iterator_v2_info:type_name -> milvus.proto.plan.SearchIteratorV2Info + 46, // 4: milvus.proto.plan.QueryInfo.json_type:type_name -> milvus.proto.schema.DataType + 46, // 5: milvus.proto.plan.ColumnInfo.data_type:type_name -> milvus.proto.schema.DataType + 46, // 6: milvus.proto.plan.ColumnInfo.element_type:type_name -> milvus.proto.schema.DataType + 16, // 7: milvus.proto.plan.ColumnExpr.info:type_name -> milvus.proto.plan.ColumnInfo + 16, // 8: milvus.proto.plan.ExistsExpr.info:type_name -> milvus.proto.plan.ColumnInfo + 12, // 9: milvus.proto.plan.ValueExpr.value:type_name -> milvus.proto.plan.GenericValue + 16, // 10: milvus.proto.plan.UnaryRangeExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo 0, // 11: milvus.proto.plan.UnaryRangeExpr.op:type_name -> milvus.proto.plan.OpType - 11, // 12: milvus.proto.plan.UnaryRangeExpr.value:type_name -> milvus.proto.plan.GenericValue - 11, // 13: milvus.proto.plan.UnaryRangeExpr.extra_values:type_name -> milvus.proto.plan.GenericValue - 15, // 14: milvus.proto.plan.BinaryRangeExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo - 11, // 15: milvus.proto.plan.BinaryRangeExpr.lower_value:type_name -> milvus.proto.plan.GenericValue - 11, // 16: milvus.proto.plan.BinaryRangeExpr.upper_value:type_name -> milvus.proto.plan.GenericValue - 37, // 17: milvus.proto.plan.CallExpr.function_parameters:type_name -> milvus.proto.plan.Expr - 15, // 18: milvus.proto.plan.CompareExpr.left_column_info:type_name -> milvus.proto.plan.ColumnInfo - 15, // 19: milvus.proto.plan.CompareExpr.right_column_info:type_name -> milvus.proto.plan.ColumnInfo + 12, // 12: milvus.proto.plan.UnaryRangeExpr.value:type_name -> milvus.proto.plan.GenericValue + 12, // 13: milvus.proto.plan.UnaryRangeExpr.extra_values:type_name -> milvus.proto.plan.GenericValue + 16, // 14: milvus.proto.plan.BinaryRangeExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo + 12, // 15: milvus.proto.plan.BinaryRangeExpr.lower_value:type_name -> milvus.proto.plan.GenericValue + 12, // 16: milvus.proto.plan.BinaryRangeExpr.upper_value:type_name -> milvus.proto.plan.GenericValue + 39, // 17: milvus.proto.plan.CallExpr.function_parameters:type_name -> milvus.proto.plan.Expr + 16, // 18: milvus.proto.plan.CompareExpr.left_column_info:type_name -> milvus.proto.plan.ColumnInfo + 16, // 19: milvus.proto.plan.CompareExpr.right_column_info:type_name -> milvus.proto.plan.ColumnInfo 0, // 20: milvus.proto.plan.CompareExpr.op:type_name -> milvus.proto.plan.OpType - 15, // 21: milvus.proto.plan.TermExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo - 11, // 22: milvus.proto.plan.TermExpr.values:type_name -> milvus.proto.plan.GenericValue - 15, // 23: milvus.proto.plan.JSONContainsExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo - 11, // 24: milvus.proto.plan.JSONContainsExpr.elements:type_name -> milvus.proto.plan.GenericValue - 6, // 25: milvus.proto.plan.JSONContainsExpr.op:type_name -> milvus.proto.plan.JSONContainsExpr.JSONOp - 15, // 26: milvus.proto.plan.NullExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo - 7, // 27: milvus.proto.plan.NullExpr.op:type_name -> milvus.proto.plan.NullExpr.NullOp - 15, // 28: milvus.proto.plan.GISFunctionFilterExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo - 8, // 29: milvus.proto.plan.GISFunctionFilterExpr.op:type_name -> milvus.proto.plan.GISFunctionFilterExpr.GISOp - 9, // 30: milvus.proto.plan.UnaryExpr.op:type_name -> milvus.proto.plan.UnaryExpr.UnaryOp - 37, // 31: milvus.proto.plan.UnaryExpr.child:type_name -> milvus.proto.plan.Expr - 10, // 32: milvus.proto.plan.BinaryExpr.op:type_name -> milvus.proto.plan.BinaryExpr.BinaryOp - 37, // 33: milvus.proto.plan.BinaryExpr.left:type_name -> milvus.proto.plan.Expr - 37, // 34: milvus.proto.plan.BinaryExpr.right:type_name -> milvus.proto.plan.Expr - 15, // 35: milvus.proto.plan.BinaryArithOp.column_info:type_name -> milvus.proto.plan.ColumnInfo + 16, // 21: milvus.proto.plan.TermExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo + 12, // 22: milvus.proto.plan.TermExpr.values:type_name -> milvus.proto.plan.GenericValue + 16, // 23: milvus.proto.plan.JSONContainsExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo + 12, // 24: milvus.proto.plan.JSONContainsExpr.elements:type_name -> milvus.proto.plan.GenericValue + 7, // 25: milvus.proto.plan.JSONContainsExpr.op:type_name -> milvus.proto.plan.JSONContainsExpr.JSONOp + 16, // 26: milvus.proto.plan.NullExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo + 8, // 27: milvus.proto.plan.NullExpr.op:type_name -> milvus.proto.plan.NullExpr.NullOp + 16, // 28: milvus.proto.plan.GISFunctionFilterExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo + 9, // 29: milvus.proto.plan.GISFunctionFilterExpr.op:type_name -> milvus.proto.plan.GISFunctionFilterExpr.GISOp + 10, // 30: milvus.proto.plan.UnaryExpr.op:type_name -> milvus.proto.plan.UnaryExpr.UnaryOp + 39, // 31: milvus.proto.plan.UnaryExpr.child:type_name -> milvus.proto.plan.Expr + 11, // 32: milvus.proto.plan.BinaryExpr.op:type_name -> milvus.proto.plan.BinaryExpr.BinaryOp + 39, // 33: milvus.proto.plan.BinaryExpr.left:type_name -> milvus.proto.plan.Expr + 39, // 34: milvus.proto.plan.BinaryExpr.right:type_name -> milvus.proto.plan.Expr + 16, // 35: milvus.proto.plan.BinaryArithOp.column_info:type_name -> milvus.proto.plan.ColumnInfo 1, // 36: milvus.proto.plan.BinaryArithOp.arith_op:type_name -> milvus.proto.plan.ArithOpType - 11, // 37: milvus.proto.plan.BinaryArithOp.right_operand:type_name -> milvus.proto.plan.GenericValue - 37, // 38: milvus.proto.plan.BinaryArithExpr.left:type_name -> milvus.proto.plan.Expr - 37, // 39: milvus.proto.plan.BinaryArithExpr.right:type_name -> milvus.proto.plan.Expr + 12, // 37: milvus.proto.plan.BinaryArithOp.right_operand:type_name -> milvus.proto.plan.GenericValue + 39, // 38: milvus.proto.plan.BinaryArithExpr.left:type_name -> milvus.proto.plan.Expr + 39, // 39: milvus.proto.plan.BinaryArithExpr.right:type_name -> milvus.proto.plan.Expr 1, // 40: milvus.proto.plan.BinaryArithExpr.op:type_name -> milvus.proto.plan.ArithOpType - 15, // 41: milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo + 16, // 41: milvus.proto.plan.BinaryArithOpEvalRangeExpr.column_info:type_name -> milvus.proto.plan.ColumnInfo 1, // 42: milvus.proto.plan.BinaryArithOpEvalRangeExpr.arith_op:type_name -> milvus.proto.plan.ArithOpType - 11, // 43: milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand:type_name -> milvus.proto.plan.GenericValue + 12, // 43: milvus.proto.plan.BinaryArithOpEvalRangeExpr.right_operand:type_name -> milvus.proto.plan.GenericValue 0, // 44: milvus.proto.plan.BinaryArithOpEvalRangeExpr.op:type_name -> milvus.proto.plan.OpType - 11, // 45: milvus.proto.plan.BinaryArithOpEvalRangeExpr.value:type_name -> milvus.proto.plan.GenericValue - 37, // 46: milvus.proto.plan.RandomSampleExpr.predicate:type_name -> milvus.proto.plan.Expr - 37, // 47: milvus.proto.plan.ElementFilterExpr.element_expr:type_name -> milvus.proto.plan.Expr - 37, // 48: milvus.proto.plan.ElementFilterExpr.predicate:type_name -> milvus.proto.plan.Expr - 15, // 49: milvus.proto.plan.TimestamptzArithCompareExpr.timestamptz_column:type_name -> milvus.proto.plan.ColumnInfo - 1, // 50: milvus.proto.plan.TimestamptzArithCompareExpr.arith_op:type_name -> milvus.proto.plan.ArithOpType - 35, // 51: milvus.proto.plan.TimestamptzArithCompareExpr.interval:type_name -> milvus.proto.plan.Interval - 0, // 52: milvus.proto.plan.TimestamptzArithCompareExpr.compare_op:type_name -> milvus.proto.plan.OpType - 11, // 53: milvus.proto.plan.TimestamptzArithCompareExpr.compare_value:type_name -> milvus.proto.plan.GenericValue - 23, // 54: milvus.proto.plan.Expr.term_expr:type_name -> milvus.proto.plan.TermExpr - 27, // 55: milvus.proto.plan.Expr.unary_expr:type_name -> milvus.proto.plan.UnaryExpr - 28, // 56: milvus.proto.plan.Expr.binary_expr:type_name -> milvus.proto.plan.BinaryExpr - 22, // 57: milvus.proto.plan.Expr.compare_expr:type_name -> milvus.proto.plan.CompareExpr - 19, // 58: milvus.proto.plan.Expr.unary_range_expr:type_name -> milvus.proto.plan.UnaryRangeExpr - 20, // 59: milvus.proto.plan.Expr.binary_range_expr:type_name -> milvus.proto.plan.BinaryRangeExpr - 31, // 60: milvus.proto.plan.Expr.binary_arith_op_eval_range_expr:type_name -> milvus.proto.plan.BinaryArithOpEvalRangeExpr - 30, // 61: milvus.proto.plan.Expr.binary_arith_expr:type_name -> milvus.proto.plan.BinaryArithExpr - 18, // 62: milvus.proto.plan.Expr.value_expr:type_name -> milvus.proto.plan.ValueExpr - 16, // 63: milvus.proto.plan.Expr.column_expr:type_name -> milvus.proto.plan.ColumnExpr - 17, // 64: milvus.proto.plan.Expr.exists_expr:type_name -> milvus.proto.plan.ExistsExpr - 34, // 65: milvus.proto.plan.Expr.always_true_expr:type_name -> milvus.proto.plan.AlwaysTrueExpr - 24, // 66: milvus.proto.plan.Expr.json_contains_expr:type_name -> milvus.proto.plan.JSONContainsExpr - 21, // 67: milvus.proto.plan.Expr.call_expr:type_name -> milvus.proto.plan.CallExpr - 25, // 68: milvus.proto.plan.Expr.null_expr:type_name -> milvus.proto.plan.NullExpr - 32, // 69: milvus.proto.plan.Expr.random_sample_expr:type_name -> milvus.proto.plan.RandomSampleExpr - 26, // 70: milvus.proto.plan.Expr.gisfunction_filter_expr:type_name -> milvus.proto.plan.GISFunctionFilterExpr - 36, // 71: milvus.proto.plan.Expr.timestamptz_arith_compare_expr:type_name -> milvus.proto.plan.TimestamptzArithCompareExpr - 33, // 72: milvus.proto.plan.Expr.element_filter_expr:type_name -> milvus.proto.plan.ElementFilterExpr - 2, // 73: milvus.proto.plan.VectorANNS.vector_type:type_name -> milvus.proto.plan.VectorType - 37, // 74: milvus.proto.plan.VectorANNS.predicates:type_name -> milvus.proto.plan.Expr - 14, // 75: milvus.proto.plan.VectorANNS.query_info:type_name -> milvus.proto.plan.QueryInfo - 37, // 76: milvus.proto.plan.QueryPlanNode.predicates:type_name -> milvus.proto.plan.Expr - 37, // 77: milvus.proto.plan.ScoreFunction.filter:type_name -> milvus.proto.plan.Expr - 3, // 78: milvus.proto.plan.ScoreFunction.type:type_name -> milvus.proto.plan.FunctionType - 45, // 79: milvus.proto.plan.ScoreFunction.params:type_name -> milvus.proto.common.KeyValuePair - 5, // 80: milvus.proto.plan.ScoreOption.boost_mode:type_name -> milvus.proto.plan.BoostMode - 4, // 81: milvus.proto.plan.ScoreOption.function_mode:type_name -> milvus.proto.plan.FunctionMode - 38, // 82: milvus.proto.plan.PlanNode.vector_anns:type_name -> milvus.proto.plan.VectorANNS - 37, // 83: milvus.proto.plan.PlanNode.predicates:type_name -> milvus.proto.plan.Expr - 39, // 84: milvus.proto.plan.PlanNode.query:type_name -> milvus.proto.plan.QueryPlanNode - 40, // 85: milvus.proto.plan.PlanNode.scorers:type_name -> milvus.proto.plan.ScoreFunction - 42, // 86: milvus.proto.plan.PlanNode.plan_options:type_name -> milvus.proto.plan.PlanOption - 41, // 87: milvus.proto.plan.PlanNode.score_option:type_name -> milvus.proto.plan.ScoreOption - 88, // [88:88] is the sub-list for method output_type - 88, // [88:88] is the sub-list for method input_type - 88, // [88:88] is the sub-list for extension type_name - 88, // [88:88] is the sub-list for extension extendee - 0, // [0:88] is the sub-list for field type_name + 12, // 45: milvus.proto.plan.BinaryArithOpEvalRangeExpr.value:type_name -> milvus.proto.plan.GenericValue + 39, // 46: milvus.proto.plan.RandomSampleExpr.predicate:type_name -> milvus.proto.plan.Expr + 39, // 47: milvus.proto.plan.ElementFilterExpr.element_expr:type_name -> milvus.proto.plan.Expr + 39, // 48: milvus.proto.plan.ElementFilterExpr.predicate:type_name -> milvus.proto.plan.Expr + 39, // 49: milvus.proto.plan.MatchExpr.predicate:type_name -> milvus.proto.plan.Expr + 3, // 50: milvus.proto.plan.MatchExpr.match_type:type_name -> milvus.proto.plan.MatchType + 16, // 51: milvus.proto.plan.TimestamptzArithCompareExpr.timestamptz_column:type_name -> milvus.proto.plan.ColumnInfo + 1, // 52: milvus.proto.plan.TimestamptzArithCompareExpr.arith_op:type_name -> milvus.proto.plan.ArithOpType + 37, // 53: milvus.proto.plan.TimestamptzArithCompareExpr.interval:type_name -> milvus.proto.plan.Interval + 0, // 54: milvus.proto.plan.TimestamptzArithCompareExpr.compare_op:type_name -> milvus.proto.plan.OpType + 12, // 55: milvus.proto.plan.TimestamptzArithCompareExpr.compare_value:type_name -> milvus.proto.plan.GenericValue + 24, // 56: milvus.proto.plan.Expr.term_expr:type_name -> milvus.proto.plan.TermExpr + 28, // 57: milvus.proto.plan.Expr.unary_expr:type_name -> milvus.proto.plan.UnaryExpr + 29, // 58: milvus.proto.plan.Expr.binary_expr:type_name -> milvus.proto.plan.BinaryExpr + 23, // 59: milvus.proto.plan.Expr.compare_expr:type_name -> milvus.proto.plan.CompareExpr + 20, // 60: milvus.proto.plan.Expr.unary_range_expr:type_name -> milvus.proto.plan.UnaryRangeExpr + 21, // 61: milvus.proto.plan.Expr.binary_range_expr:type_name -> milvus.proto.plan.BinaryRangeExpr + 32, // 62: milvus.proto.plan.Expr.binary_arith_op_eval_range_expr:type_name -> milvus.proto.plan.BinaryArithOpEvalRangeExpr + 31, // 63: milvus.proto.plan.Expr.binary_arith_expr:type_name -> milvus.proto.plan.BinaryArithExpr + 19, // 64: milvus.proto.plan.Expr.value_expr:type_name -> milvus.proto.plan.ValueExpr + 17, // 65: milvus.proto.plan.Expr.column_expr:type_name -> milvus.proto.plan.ColumnExpr + 18, // 66: milvus.proto.plan.Expr.exists_expr:type_name -> milvus.proto.plan.ExistsExpr + 36, // 67: milvus.proto.plan.Expr.always_true_expr:type_name -> milvus.proto.plan.AlwaysTrueExpr + 25, // 68: milvus.proto.plan.Expr.json_contains_expr:type_name -> milvus.proto.plan.JSONContainsExpr + 22, // 69: milvus.proto.plan.Expr.call_expr:type_name -> milvus.proto.plan.CallExpr + 26, // 70: milvus.proto.plan.Expr.null_expr:type_name -> milvus.proto.plan.NullExpr + 33, // 71: milvus.proto.plan.Expr.random_sample_expr:type_name -> milvus.proto.plan.RandomSampleExpr + 27, // 72: milvus.proto.plan.Expr.gisfunction_filter_expr:type_name -> milvus.proto.plan.GISFunctionFilterExpr + 38, // 73: milvus.proto.plan.Expr.timestamptz_arith_compare_expr:type_name -> milvus.proto.plan.TimestamptzArithCompareExpr + 34, // 74: milvus.proto.plan.Expr.element_filter_expr:type_name -> milvus.proto.plan.ElementFilterExpr + 35, // 75: milvus.proto.plan.Expr.match_expr:type_name -> milvus.proto.plan.MatchExpr + 2, // 76: milvus.proto.plan.VectorANNS.vector_type:type_name -> milvus.proto.plan.VectorType + 39, // 77: milvus.proto.plan.VectorANNS.predicates:type_name -> milvus.proto.plan.Expr + 15, // 78: milvus.proto.plan.VectorANNS.query_info:type_name -> milvus.proto.plan.QueryInfo + 39, // 79: milvus.proto.plan.QueryPlanNode.predicates:type_name -> milvus.proto.plan.Expr + 39, // 80: milvus.proto.plan.ScoreFunction.filter:type_name -> milvus.proto.plan.Expr + 4, // 81: milvus.proto.plan.ScoreFunction.type:type_name -> milvus.proto.plan.FunctionType + 47, // 82: milvus.proto.plan.ScoreFunction.params:type_name -> milvus.proto.common.KeyValuePair + 6, // 83: milvus.proto.plan.ScoreOption.boost_mode:type_name -> milvus.proto.plan.BoostMode + 5, // 84: milvus.proto.plan.ScoreOption.function_mode:type_name -> milvus.proto.plan.FunctionMode + 40, // 85: milvus.proto.plan.PlanNode.vector_anns:type_name -> milvus.proto.plan.VectorANNS + 39, // 86: milvus.proto.plan.PlanNode.predicates:type_name -> milvus.proto.plan.Expr + 41, // 87: milvus.proto.plan.PlanNode.query:type_name -> milvus.proto.plan.QueryPlanNode + 42, // 88: milvus.proto.plan.PlanNode.scorers:type_name -> milvus.proto.plan.ScoreFunction + 44, // 89: milvus.proto.plan.PlanNode.plan_options:type_name -> milvus.proto.plan.PlanOption + 43, // 90: milvus.proto.plan.PlanNode.score_option:type_name -> milvus.proto.plan.ScoreOption + 91, // [91:91] is the sub-list for method output_type + 91, // [91:91] is the sub-list for method input_type + 91, // [91:91] is the sub-list for extension type_name + 91, // [91:91] is the sub-list for extension extendee + 0, // [0:91] is the sub-list for field type_name } func init() { file_plan_proto_init() } @@ -4406,7 +4573,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AlwaysTrueExpr); i { + switch v := v.(*MatchExpr); i { case 0: return &v.state case 1: @@ -4418,7 +4585,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Interval); i { + switch v := v.(*AlwaysTrueExpr); i { case 0: return &v.state case 1: @@ -4430,7 +4597,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TimestamptzArithCompareExpr); i { + switch v := v.(*Interval); i { case 0: return &v.state case 1: @@ -4442,7 +4609,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Expr); i { + switch v := v.(*TimestamptzArithCompareExpr); i { case 0: return &v.state case 1: @@ -4454,7 +4621,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*VectorANNS); i { + switch v := v.(*Expr); i { case 0: return &v.state case 1: @@ -4466,7 +4633,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryPlanNode); i { + switch v := v.(*VectorANNS); i { case 0: return &v.state case 1: @@ -4478,7 +4645,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ScoreFunction); i { + switch v := v.(*QueryPlanNode); i { case 0: return &v.state case 1: @@ -4490,7 +4657,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ScoreOption); i { + switch v := v.(*ScoreFunction); i { case 0: return &v.state case 1: @@ -4502,7 +4669,7 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PlanOption); i { + switch v := v.(*ScoreOption); i { case 0: return &v.state case 1: @@ -4514,6 +4681,18 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PlanOption); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_plan_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PlanNode); i { case 0: return &v.state @@ -4535,7 +4714,7 @@ func file_plan_proto_init() { } file_plan_proto_msgTypes[2].OneofWrappers = []interface{}{} file_plan_proto_msgTypes[3].OneofWrappers = []interface{}{} - file_plan_proto_msgTypes[26].OneofWrappers = []interface{}{ + file_plan_proto_msgTypes[27].OneofWrappers = []interface{}{ (*Expr_TermExpr)(nil), (*Expr_UnaryExpr)(nil), (*Expr_BinaryExpr)(nil), @@ -4555,8 +4734,9 @@ func file_plan_proto_init() { (*Expr_GisfunctionFilterExpr)(nil), (*Expr_TimestamptzArithCompareExpr)(nil), (*Expr_ElementFilterExpr)(nil), + (*Expr_MatchExpr)(nil), } - file_plan_proto_msgTypes[32].OneofWrappers = []interface{}{ + file_plan_proto_msgTypes[33].OneofWrappers = []interface{}{ (*PlanNode_VectorAnns)(nil), (*PlanNode_Predicates)(nil), (*PlanNode_Query)(nil), @@ -4566,8 +4746,8 @@ func file_plan_proto_init() { File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_plan_proto_rawDesc, - NumEnums: 11, - NumMessages: 33, + NumEnums: 12, + NumMessages: 34, NumExtensions: 0, NumServices: 0, },