You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@doris.apache.org by zh...@apache.org on 2023/04/28 09:18:06 UTC
[doris] branch master updated: [feature-wip](partial update) PART1: support basic partial write (#17542)
This is an automated email from the ASF dual-hosted git repository.
zhangchen pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new aef9355cd3 [feature-wip](partial update) PART1: support basic partial write (#17542)
aef9355cd3 is described below
commit aef9355cd3283bbc6f0475eb2923074f855a413d
Author: yixiutt <10...@users.noreply.github.com>
AuthorDate: Fri Apr 28 17:17:57 2023 +0800
[feature-wip](partial update) PART1: support basic partial write (#17542)
---
be/src/exec/tablet_info.cpp | 20 +
be/src/exec/tablet_info.h | 7 +
be/src/http/action/stream_load.cpp | 7 +
be/src/http/http_common.h | 2 +-
be/src/olap/delta_writer.cpp | 24 +-
be/src/olap/memtable.cpp | 65 +-
be/src/olap/memtable.h | 68 +-
be/src/olap/olap_common.h | 19 +
be/src/olap/rowset/beta_rowset_writer.cpp | 17 +-
be/src/olap/rowset/beta_rowset_writer.h | 5 +
be/src/olap/rowset/rowset.cpp | 12 +
be/src/olap/rowset/rowset.h | 4 +
be/src/olap/rowset/rowset_meta.h | 5 +
be/src/olap/rowset/rowset_writer.h | 2 +
be/src/olap/rowset/rowset_writer_context.h | 2 +
be/src/olap/rowset/segment_v2/segment.cpp | 4 +-
be/src/olap/rowset/segment_v2/segment.h | 2 +-
be/src/olap/rowset/segment_v2/segment_writer.cpp | 240 +-
be/src/olap/rowset/segment_v2/segment_writer.h | 27 +-
be/src/olap/rowset/vertical_beta_rowset_writer.cpp | 6 +-
be/src/olap/segment_loader.cpp | 4 +
be/src/olap/segment_loader.h | 2 +
be/src/olap/tablet.cpp | 417 +-
be/src/olap/tablet.h | 39 +-
be/src/olap/tablet_schema.cpp | 72 +
be/src/olap/tablet_schema.h | 19 +
be/src/olap/txn_manager.cpp | 37 +-
be/src/olap/txn_manager.h | 8 +
be/src/service/point_query_executor.cpp | 2 +-
be/src/vec/jsonb/serialize.cpp | 28 +
be/src/vec/jsonb/serialize.h | 11 +
be/src/vec/olap/olap_data_convertor.cpp | 10 +
be/src/vec/olap/olap_data_convertor.h | 2 +
be/test/io/cache/remote_file_cache_test.cpp | 3 +-
be/test/olap/tablet_test.cpp | 18 +-
be/test/olap/test_data/header_without_inc_rs.txt | 3 +-
.../src/main/java/org/apache/doris/load/Load.java | 13 +-
.../doris/load/routineload/RoutineLoadJob.java | 5 +
.../org/apache/doris/planner/FileLoadScanNode.java | 4 +-
.../org/apache/doris/planner/OlapTableSink.java | 15 +
.../apache/doris/planner/StreamLoadPlanner.java | 34 +-
.../doris/planner/external/FileGroupInfo.java | 8 +-
.../doris/planner/external/LoadScanProvider.java | 2 +-
.../java/org/apache/doris/task/LoadTaskInfo.java | 2 +
.../java/org/apache/doris/task/StreamLoadTask.java | 10 +
gensrc/proto/descriptors.proto | 2 +
gensrc/proto/olap_file.proto | 2 +
gensrc/thrift/Descriptors.thrift | 2 +
gensrc/thrift/FrontendService.thrift | 1 +
.../unique_with_mow_p0/partial_update/10000.csv | 10001 ++++++++++++++++++
.../partial_update/10000_update_1.csv | 10001 ++++++++++++++++++
.../unique_with_mow_p0/partial_update/basic.csv | 2 +
.../unique_with_mow_p0/partial_update/basic.orc | Bin 0 -> 1362 bytes
.../unique_with_mow_p0/partial_update/default.csv | 3 +
.../partial_update/test_partial_update.out | 5 +
.../test_partial_update_default_value.out | 6 +
.../partial_update/test_partial_update_orc.out | 53 +
.../partial_update/test_partial_update_publish.out | 10004 +++++++++++++++++++
.../test_partial_update_with_row_column.out | 5 +
.../unique_with_mow_p0/partial_update/update.orc | Bin 0 -> 548 bytes
.../partial_update/test_partial_update.groovy | 61 +
.../test_partial_update_default_value.groovy | 61 +
.../partial_update/test_partial_update_orc.groovy | 60 +
.../test_partial_update_publish.groovy | 70 +
.../test_partial_update_with_row_column.groovy | 62 +
65 files changed, 31530 insertions(+), 177 deletions(-)
diff --git a/be/src/exec/tablet_info.cpp b/be/src/exec/tablet_info.cpp
index 1b79278d8b..4191865f2a 100644
--- a/be/src/exec/tablet_info.cpp
+++ b/be/src/exec/tablet_info.cpp
@@ -60,6 +60,11 @@ Status OlapTableSchemaParam::init(const POlapTableSchemaParam& pschema) {
_db_id = pschema.db_id();
_table_id = pschema.table_id();
_version = pschema.version();
+ _is_partial_update = pschema.partial_update();
+
+ for (auto& col : pschema.partial_update_input_columns()) {
+ _partial_update_input_columns.insert(col);
+ }
std::map<std::string, SlotDescriptor*> slots_map;
_tuple_desc = _obj_pool.add(new TupleDescriptor(pschema.tuple_desc()));
@@ -74,6 +79,9 @@ Status OlapTableSchemaParam::init(const POlapTableSchemaParam& pschema) {
index->index_id = p_index.id();
index->schema_hash = p_index.schema_hash();
for (auto& col : p_index.columns()) {
+ if (_is_partial_update && _partial_update_input_columns.count(col) == 0) {
+ continue;
+ }
auto it = slots_map.find(col);
if (it == std::end(slots_map)) {
return Status::InternalError("unknown index column, column={}", col);
@@ -105,6 +113,11 @@ Status OlapTableSchemaParam::init(const TOlapTableSchemaParam& tschema) {
_table_id = tschema.table_id;
_version = tschema.version;
_is_dynamic_schema = tschema.is_dynamic_schema;
+ _is_partial_update = tschema.is_partial_update;
+
+ for (auto& tcolumn : tschema.partial_update_input_columns) {
+ _partial_update_input_columns.insert(tcolumn);
+ }
std::map<std::string, SlotDescriptor*> slots_map;
_tuple_desc = _obj_pool.add(new TupleDescriptor(tschema.tuple_desc));
for (auto& t_slot_desc : tschema.slot_descs) {
@@ -118,6 +131,9 @@ Status OlapTableSchemaParam::init(const TOlapTableSchemaParam& tschema) {
index->index_id = t_index.id;
index->schema_hash = t_index.schema_hash;
for (auto& col : t_index.columns) {
+ if (_is_partial_update && _partial_update_input_columns.count(col) == 0) {
+ continue;
+ }
auto it = slots_map.find(col);
if (it == std::end(slots_map)) {
return Status::InternalError("unknown index column, column={}", col);
@@ -163,6 +179,10 @@ void OlapTableSchemaParam::to_protobuf(POlapTableSchemaParam* pschema) const {
pschema->set_db_id(_db_id);
pschema->set_table_id(_table_id);
pschema->set_version(_version);
+ pschema->set_partial_update(_is_partial_update);
+ for (auto col : _partial_update_input_columns) {
+ *pschema->add_partial_update_input_columns() = col;
+ }
_tuple_desc->to_protobuf(pschema->mutable_tuple_desc());
for (auto slot : _tuple_desc->slots()) {
slot->to_protobuf(pschema->add_slot_descs());
diff --git a/be/src/exec/tablet_info.h b/be/src/exec/tablet_info.h
index 4840187e56..b4146ba6e0 100644
--- a/be/src/exec/tablet_info.h
+++ b/be/src/exec/tablet_info.h
@@ -87,6 +87,11 @@ public:
bool is_dynamic_schema() const { return _is_dynamic_schema; }
+ bool is_partial_update() const { return _is_partial_update; }
+ std::set<std::string> partial_update_input_columns() const {
+ return _partial_update_input_columns;
+ }
+
std::string debug_string() const;
private:
@@ -99,6 +104,8 @@ private:
std::vector<OlapTableIndexSchema*> _indexes;
mutable ObjectPool _obj_pool;
bool _is_dynamic_schema = false;
+ bool _is_partial_update = false;
+ std::set<std::string> _partial_update_input_columns;
};
using OlapTableIndexTablets = TOlapTableIndexTablets;
diff --git a/be/src/http/action/stream_load.cpp b/be/src/http/action/stream_load.cpp
index 925a8ad8e0..0e59c4c7ac 100644
--- a/be/src/http/action/stream_load.cpp
+++ b/be/src/http/action/stream_load.cpp
@@ -592,6 +592,13 @@ Status StreamLoadAction::_process_put(HttpRequest* http_req,
request.__set_enable_profile(false);
}
}
+ if (!http_req->header(HTTP_PARTIAL_COLUMNS).empty()) {
+ if (iequal(http_req->header(HTTP_PARTIAL_COLUMNS), "true")) {
+ request.__set_partial_update(true);
+ } else {
+ request.__set_partial_update(false);
+ }
+ }
#ifndef BE_TEST
// plan this load
diff --git a/be/src/http/http_common.h b/be/src/http/http_common.h
index 2295731d6a..86df938af1 100644
--- a/be/src/http/http_common.h
+++ b/be/src/http/http_common.h
@@ -55,7 +55,7 @@ static const std::string HTTP_TRIM_DOUBLE_QUOTES = "trim_double_quotes";
static const std::string HTTP_SKIP_LINES = "skip_lines";
static const std::string HTTP_COMMENT = "comment";
static const std::string HTTP_ENABLE_PROFILE = "enable_profile";
-
+static const std::string HTTP_PARTIAL_COLUMNS = "partial_columns";
static const std::string HTTP_TWO_PHASE_COMMIT = "two_phase_commit";
static const std::string HTTP_TXN_ID_KEY = "txn_id";
static const std::string HTTP_TXN_OPERATION_KEY = "txn_operation";
diff --git a/be/src/olap/delta_writer.cpp b/be/src/olap/delta_writer.cpp
index 54bb6a7fa0..1281cc913f 100644
--- a/be/src/olap/delta_writer.cpp
+++ b/be/src/olap/delta_writer.cpp
@@ -161,6 +161,9 @@ Status DeltaWriter::init() {
RETURN_NOT_OK(_storage_engine->txn_manager()->prepare_txn(_req.partition_id, _tablet,
_req.txn_id, _req.load_id));
}
+ if (_tablet->enable_unique_key_merge_on_write() && _delete_bitmap == nullptr) {
+ _delete_bitmap.reset(new DeleteBitmap(_tablet->tablet_id()));
+ }
// build tablet schema in request level
_build_current_tablet_schema(_req.index_id, _req.table_schema_param, *_tablet->tablet_schema());
RowsetWriterContext context;
@@ -171,9 +174,12 @@ Status DeltaWriter::init() {
context.tablet_schema = _tablet_schema;
context.newest_write_timestamp = UnixSeconds();
context.tablet_id = _tablet->table_id();
- context.is_direct_write = true;
context.tablet = _tablet;
+ context.is_direct_write = true;
+ context.mow_context =
+ std::make_shared<MowContext>(_cur_max_version, _rowset_ids, _delete_bitmap);
RETURN_NOT_OK(_tablet->create_rowset_writer(context, &_rowset_writer));
+
_schema.reset(new Schema(_tablet_schema));
_reset_mem_table();
@@ -285,9 +291,6 @@ Status DeltaWriter::wait_flush() {
}
void DeltaWriter::_reset_mem_table() {
- if (_tablet->enable_unique_key_merge_on_write() && _delete_bitmap == nullptr) {
- _delete_bitmap.reset(new DeleteBitmap(_tablet->tablet_id()));
- }
#ifndef BE_TEST
auto mem_table_insert_tracker = std::make_shared<MemTracker>(
fmt::format("MemTableManualInsert:TabletId={}:MemTableNum={}#loadID={}",
@@ -310,10 +313,10 @@ void DeltaWriter::_reset_mem_table() {
_mem_table_insert_trackers.push_back(mem_table_insert_tracker);
_mem_table_flush_trackers.push_back(mem_table_flush_tracker);
}
+ auto mow_context = std::make_shared<MowContext>(_cur_max_version, _rowset_ids, _delete_bitmap);
_mem_table.reset(new MemTable(_tablet, _schema.get(), _tablet_schema.get(), _req.slots,
- _req.tuple_desc, _rowset_writer.get(), _delete_bitmap,
- _rowset_ids, _cur_max_version, mem_table_insert_tracker,
- mem_table_flush_tracker));
+ _req.tuple_desc, _rowset_writer.get(), mow_context,
+ mem_table_insert_tracker, mem_table_flush_tracker));
}
Status DeltaWriter::close() {
@@ -397,8 +400,8 @@ Status DeltaWriter::close_wait(const PSlaveTabletNodes& slave_tablet_nodes,
SchemaChangeHandler::tablet_in_converting(_tablet->tablet_id())) {
return Status::OK();
}
- RETURN_IF_ERROR(_tablet->calc_delete_bitmap(beta_rowset->rowset_id(), segments, nullptr,
- _delete_bitmap, _cur_max_version, true));
+ RETURN_IF_ERROR(_tablet->calc_delete_bitmap(_cur_rowset, segments, nullptr, _delete_bitmap,
+ _cur_max_version, true));
_storage_engine->txn_manager()->set_txn_related_delete_bitmap(
_req.partition_id, _req.txn_id, _tablet->tablet_id(), _tablet->schema_hash(),
_tablet->tablet_uid(), true, _delete_bitmap, _rowset_ids,
@@ -530,6 +533,9 @@ void DeltaWriter::_build_current_tablet_schema(int64_t index_id,
}
_tablet_schema->set_table_id(table_schema_param->table_id());
+ // set partial update columns info
+ _tablet_schema->set_partial_update_info(table_schema_param->is_partial_update(),
+ table_schema_param->partial_update_input_columns());
}
void DeltaWriter::_request_slave_tablet_pull_rowset(PNodeInfo node_info) {
diff --git a/be/src/olap/memtable.cpp b/be/src/olap/memtable.cpp
index 56cf5bff1b..85ac69b16c 100644
--- a/be/src/olap/memtable.cpp
+++ b/be/src/olap/memtable.cpp
@@ -59,8 +59,7 @@ using namespace ErrorCode;
MemTable::MemTable(TabletSharedPtr tablet, Schema* schema, const TabletSchema* tablet_schema,
const std::vector<SlotDescriptor*>* slot_descs, TupleDescriptor* tuple_desc,
- RowsetWriter* rowset_writer, DeleteBitmapPtr delete_bitmap,
- const RowsetIdUnorderedSet& rowset_ids, int64_t cur_max_version,
+ RowsetWriter* rowset_writer, std::shared_ptr<MowContext> mow_context,
const std::shared_ptr<MemTracker>& insert_mem_tracker,
const std::shared_ptr<MemTracker>& flush_mem_tracker)
: _tablet(std::move(tablet)),
@@ -76,9 +75,7 @@ MemTable::MemTable(TabletSharedPtr tablet, Schema* schema, const TabletSchema* t
_offsets_of_aggregate_states(schema->num_columns()),
_total_size_of_aggregate_states(0),
_mem_usage(0),
- _delete_bitmap(delete_bitmap),
- _rowset_ids(rowset_ids),
- _cur_max_version(cur_max_version) {
+ _mow_context(mow_context) {
#ifndef BE_TEST
_insert_mem_tracker_use_hook = std::make_unique<MemTracker>(
fmt::format("MemTableHookInsert:TabletId={}", std::to_string(tablet_id())),
@@ -93,6 +90,10 @@ MemTable::MemTable(TabletSharedPtr tablet, Schema* schema, const TabletSchema* t
_vec_skip_list = std::make_unique<VecTable>(_vec_row_comparator.get(), _arena.get(),
_keys_type == KeysType::DUP_KEYS);
_init_columns_offset_by_slot_descs(slot_descs, tuple_desc);
+ _num_columns = _tablet_schema->num_columns();
+ if (_tablet_schema->is_partial_update()) {
+ _num_columns = _tablet_schema->partial_input_column_size();
+ }
}
void MemTable::_init_columns_offset_by_slot_descs(const std::vector<SlotDescriptor*>* slot_descs,
const TupleDescriptor* tuple_desc) {
@@ -108,7 +109,7 @@ void MemTable::_init_columns_offset_by_slot_descs(const std::vector<SlotDescript
}
void MemTable::_init_agg_functions(const vectorized::Block* block) {
- for (uint32_t cid = _schema->num_key_columns(); cid < _schema->num_columns(); ++cid) {
+ for (uint32_t cid = _schema->num_key_columns(); cid < _num_columns; ++cid) {
vectorized::AggregateFunctionPtr function;
if (_keys_type == KeysType::UNIQUE_KEYS && _tablet->enable_unique_key_merge_on_write()) {
// In such table, non-key column's aggregation type is NONE, so we need to construct
@@ -125,12 +126,12 @@ void MemTable::_init_agg_functions(const vectorized::Block* block) {
_agg_functions[cid] = function;
}
- for (uint32_t cid = _schema->num_key_columns(); cid < _schema->num_columns(); ++cid) {
+ for (uint32_t cid = _schema->num_key_columns(); cid < _num_columns; ++cid) {
_offsets_of_aggregate_states[cid] = _total_size_of_aggregate_states;
_total_size_of_aggregate_states += _agg_functions[cid]->size_of_data();
// If not the last aggregate_state, we need pad it so that next aggregate_state will be aligned.
- if (cid + 1 < _agg_functions.size()) {
+ if (cid + 1 < _num_columns) {
size_t alignment_of_next_state = _agg_functions[cid + 1]->align_of_data();
/// Extend total_size to next alignment requirement
@@ -148,7 +149,7 @@ MemTable::~MemTable() {
for (it.SeekToFirst(); it.Valid(); it.Next()) {
// We should release agg_places here, because they are not released when a
// load is canceled.
- for (size_t i = _schema->num_key_columns(); i < _schema->num_columns(); ++i) {
+ for (size_t i = _schema->num_key_columns(); i < _num_columns; ++i) {
auto function = _agg_functions[i];
DCHECK(function != nullptr);
DCHECK(it.key()->agg_places(i) != nullptr);
@@ -165,8 +166,7 @@ MemTable::~MemTable() {
DCHECK_EQ(_flush_mem_tracker->consumption(), 0);
}
-int MemTable::RowInBlockComparator::operator()(const RowInBlock* left,
- const RowInBlock* right) const {
+int RowInBlockComparator::operator()(const RowInBlock* left, const RowInBlock* right) const {
return _pblock->compare_at(left->_row_pos, right->_row_pos, _schema->num_key_columns(),
*_pblock, -1);
}
@@ -226,7 +226,7 @@ void MemTable::_insert_one_row_from_block(RowInBlock* row_in_block) {
} else {
row_in_block->init_agg_places(_arena->aligned_alloc(_total_size_of_aggregate_states, 16),
_offsets_of_aggregate_states.data());
- for (auto cid = _schema->num_key_columns(); cid < _schema->num_columns(); cid++) {
+ for (auto cid = _schema->num_key_columns(); cid < _num_columns; cid++) {
try {
auto col_ptr = _input_mutable_block.mutable_columns()[cid].get();
auto data = row_in_block->agg_places(cid);
@@ -241,7 +241,6 @@ void MemTable::_insert_one_row_from_block(RowInBlock* row_in_block) {
throw;
}
}
-
_vec_skip_list->InsertWithHint(row_in_block, is_exist, &_vec_hint);
}
}
@@ -261,7 +260,7 @@ void MemTable::_aggregate_two_row_in_block(RowInBlock* new_row, RowInBlock* row_
row_in_skiplist->_row_pos = new_row->_row_pos;
}
// dst is non-sequence row, or dst sequence is smaller
- for (uint32_t cid = _schema->num_key_columns(); cid < _schema->num_columns(); ++cid) {
+ for (uint32_t cid = _schema->num_key_columns(); cid < _num_columns; ++cid) {
auto col_ptr = _input_mutable_block.mutable_columns()[cid].get();
_agg_functions[cid]->add(row_in_skiplist->agg_places(cid),
const_cast<const doris::vectorized::IColumn**>(&col_ptr),
@@ -303,7 +302,7 @@ void MemTable::_collect_vskiplist_results() {
*block_data[i].column.get(), it.key()->_row_pos);
}
// get value columns from agg_places
- for (size_t i = _schema->num_key_columns(); i < _schema->num_columns(); ++i) {
+ for (size_t i = _schema->num_key_columns(); i < _num_columns; ++i) {
auto function = _agg_functions[i];
auto agg_place = it.key()->agg_places(i);
auto col_ptr = _output_mutable_block.get_column_by_position(i).get();
@@ -353,14 +352,25 @@ void MemTable::shrink_memtable_by_agg() {
}
bool MemTable::need_flush() const {
- return memory_usage() >= config::write_buffer_size;
+ auto max_size = config::write_buffer_size;
+ if (_tablet_schema->is_partial_update()) {
+ auto update_columns_size = _tablet_schema->partial_input_column_size();
+ max_size = max_size * update_columns_size / _tablet_schema->num_columns();
+ max_size = max_size > 1048576 ? max_size : 1048576;
+ }
+ return memory_usage() >= max_size;
}
bool MemTable::need_agg() const {
if (_keys_type == KeysType::AGG_KEYS) {
- return memory_usage() >= config::write_buffer_size_for_agg;
+ auto max_size = config::write_buffer_size_for_agg;
+ if (_tablet_schema->is_partial_update()) {
+ auto update_columns_size = _tablet_schema->partial_input_column_size();
+ max_size = max_size * update_columns_size / _tablet_schema->num_columns();
+ max_size = max_size > 1048576 ? max_size : 1048576;
+ }
+ return memory_usage() >= max_size;
}
-
return false;
}
@@ -384,8 +394,9 @@ Status MemTable::_generate_delete_bitmap(int64_t atomic_num_segments_before_flus
SchemaChangeHandler::tablet_in_converting(_tablet->tablet_id())) {
return Status::OK();
}
- RETURN_IF_ERROR(_tablet->calc_delete_bitmap(beta_rowset->rowset_id(), segments, &_rowset_ids,
- _delete_bitmap, _cur_max_version));
+ RETURN_IF_ERROR(_tablet->calc_delete_bitmap(rowset, segments, &_mow_context->rowset_ids,
+ _mow_context->delete_bitmap,
+ _mow_context->max_version));
return Status::OK();
}
@@ -400,8 +411,10 @@ Status MemTable::flush() {
int64_t atomic_num_segments_before_flush = _rowset_writer->get_atomic_num_segment();
RETURN_NOT_OK(_do_flush(duration_ns));
int64_t atomic_num_segments_after_flush = _rowset_writer->get_atomic_num_segment();
- RETURN_NOT_OK(_generate_delete_bitmap(atomic_num_segments_before_flush,
- atomic_num_segments_after_flush));
+ if (!_tablet_schema->is_partial_update()) {
+ RETURN_NOT_OK(_generate_delete_bitmap(atomic_num_segments_before_flush,
+ atomic_num_segments_after_flush));
+ }
DorisMetrics::instance()->memtable_flush_total->increment(1);
DorisMetrics::instance()->memtable_flush_duration_us->increment(duration_ns / 1000);
VLOG_CRITICAL << "after flush memtable for tablet: " << tablet_id()
@@ -415,10 +428,6 @@ Status MemTable::_do_flush(int64_t& duration_ns) {
SCOPED_RAW_TIMER(&duration_ns);
_collect_vskiplist_results<true>();
vectorized::Block block = _output_mutable_block.to_block();
- if (_tablet_schema->store_row_column()) {
- // convert block to row store format
- serialize_block_to_row_column(block);
- }
if (_tablet_schema->is_dynamic_schema()) {
// Unfold variant column
unfold_variant_column(block);
@@ -462,7 +471,7 @@ void MemTable::serialize_block_to_row_column(vectorized::Block& block) {
watch.start();
// find row column id
int row_column_id = 0;
- for (int i = 0; i < _tablet_schema->num_columns(); ++i) {
+ for (int i = 0; i < _num_columns; ++i) {
if (_tablet_schema->column(i).is_row_store_column()) {
row_column_id = i;
break;
@@ -478,7 +487,7 @@ void MemTable::serialize_block_to_row_column(vectorized::Block& block) {
.get());
row_store_column->clear();
vectorized::JsonbSerializeUtil::block_to_jsonb(*_tablet_schema, block, *row_store_column,
- _tablet_schema->num_columns());
+ _num_columns);
VLOG_DEBUG << "serialize , num_rows:" << block.rows() << ", row_column_id:" << row_column_id
<< ", total_byte_size:" << block.allocated_bytes() << ", serialize_cost(us)"
<< watch.elapsed_time() / 1000;
diff --git a/be/src/olap/memtable.h b/be/src/olap/memtable.h
index f50b78c0b1..c6e96f463e 100644
--- a/be/src/olap/memtable.h
+++ b/be/src/olap/memtable.h
@@ -44,12 +44,41 @@ class TabletSchema;
class TupleDescriptor;
enum KeysType : int;
+// row pos in _input_mutable_block
+struct RowInBlock {
+ size_t _row_pos;
+ char* _agg_mem;
+ size_t* _agg_state_offset;
+
+ RowInBlock(size_t row) : _row_pos(row) {}
+
+ void init_agg_places(char* agg_mem, size_t* agg_state_offset) {
+ _agg_mem = agg_mem;
+ _agg_state_offset = agg_state_offset;
+ }
+
+ char* agg_places(size_t offset) const { return _agg_mem + _agg_state_offset[offset]; }
+};
+
+class RowInBlockComparator {
+public:
+ RowInBlockComparator(const Schema* schema) : _schema(schema) {}
+ // call set_block before operator().
+ // only first time insert block to create _input_mutable_block,
+ // so can not Comparator of construct to set pblock
+ void set_block(vectorized::MutableBlock* pblock) { _pblock = pblock; }
+ int operator()(const RowInBlock* left, const RowInBlock* right) const;
+
+private:
+ const Schema* _schema;
+ vectorized::MutableBlock* _pblock; // 对应Memtable::_input_mutable_block
+};
+
class MemTable {
public:
MemTable(TabletSharedPtr tablet, Schema* schema, const TabletSchema* tablet_schema,
const std::vector<SlotDescriptor*>* slot_descs, TupleDescriptor* tuple_desc,
- RowsetWriter* rowset_writer, DeleteBitmapPtr delete_bitmap,
- const RowsetIdUnorderedSet& rowset_ids, int64_t cur_max_version,
+ RowsetWriter* rowset_writer, std::shared_ptr<MowContext> mow_context,
const std::shared_ptr<MemTracker>& insert_mem_tracker,
const std::shared_ptr<MemTracker>& flush_mem_tracker);
~MemTable();
@@ -79,36 +108,6 @@ public:
private:
Status _do_flush(int64_t& duration_ns);
- // row pos in _input_mutable_block
- struct RowInBlock {
- size_t _row_pos;
- char* _agg_mem;
- size_t* _agg_state_offset;
-
- RowInBlock(size_t row) : _row_pos(row) {}
-
- void init_agg_places(char* agg_mem, size_t* agg_state_offset) {
- _agg_mem = agg_mem;
- _agg_state_offset = agg_state_offset;
- }
-
- char* agg_places(size_t offset) const { return _agg_mem + _agg_state_offset[offset]; }
- };
-
- class RowInBlockComparator {
- public:
- RowInBlockComparator(const Schema* schema) : _schema(schema) {}
- // call set_block before operator().
- // only first time insert block to create _input_mutable_block,
- // so can not Comparator of construct to set pblock
- void set_block(vectorized::MutableBlock* pblock) { _pblock = pblock; }
- int operator()(const RowInBlock* left, const RowInBlock* right) const;
-
- private:
- const Schema* _schema;
- vectorized::MutableBlock* _pblock; // 对应Memtable::_input_mutable_block
- };
-
private:
using VecTable = SkipList<RowInBlock*, RowInBlockComparator>;
@@ -192,9 +191,8 @@ private:
// Memory usage without _arena.
size_t _mem_usage;
- DeleteBitmapPtr _delete_bitmap;
- RowsetIdUnorderedSet _rowset_ids;
- int64_t _cur_max_version;
+ std::shared_ptr<MowContext> _mow_context;
+ size_t _num_columns;
}; // class MemTable
inline std::ostream& operator<<(std::ostream& os, const MemTable& table) {
diff --git a/be/src/olap/olap_common.h b/be/src/olap/olap_common.h
index ad81578a6a..46964fadba 100644
--- a/be/src/olap/olap_common.h
+++ b/be/src/olap/olap_common.h
@@ -463,4 +463,23 @@ struct HashOfRowsetId {
using RowsetIdUnorderedSet = std::unordered_set<RowsetId, HashOfRowsetId>;
+class DeleteBitmap;
+// merge on write context
+struct MowContext {
+ MowContext(int64_t version, const RowsetIdUnorderedSet& ids, std::shared_ptr<DeleteBitmap> db)
+ : max_version(version), rowset_ids(ids), delete_bitmap(db) {}
+ int64_t max_version;
+ const RowsetIdUnorderedSet& rowset_ids;
+ std::shared_ptr<DeleteBitmap> delete_bitmap;
+};
+
+// used in mow partial update
+struct RidAndPos {
+ uint32_t rid;
+ // pos in block
+ size_t pos;
+};
+
+using PartialUpdateReadPlan = std::map<RowsetId, std::map<uint32_t, std::vector<RidAndPos>>>;
+
} // namespace doris
diff --git a/be/src/olap/rowset/beta_rowset_writer.cpp b/be/src/olap/rowset/beta_rowset_writer.cpp
index 744cf8066c..224944d917 100644
--- a/be/src/olap/rowset/beta_rowset_writer.cpp
+++ b/be/src/olap/rowset/beta_rowset_writer.cpp
@@ -61,6 +61,7 @@ BetaRowsetWriter::BetaRowsetWriter()
: _rowset_meta(nullptr),
_num_segment(0),
_num_flushed_segment(0),
+ _segment_start_id(0),
_segcompacted_point(0),
_num_segcompacted(0),
_segment_writer(nullptr),
@@ -681,7 +682,7 @@ Status BetaRowsetWriter::_do_create_segment_writer(
path = BetaRowset::local_segment_path_segcompacted(_context.rowset_dir, _context.rowset_id,
begin, end);
} else {
- segment_id = _num_segment.fetch_add(1);
+ segment_id = _num_segment.fetch_add(1) + _segment_start_id;
path = BetaRowset::segment_file_path(_context.rowset_dir, _context.rowset_id, segment_id);
}
auto fs = _rowset_meta->fs();
@@ -702,17 +703,19 @@ Status BetaRowsetWriter::_do_create_segment_writer(
writer_options.is_direct_write = _context.is_direct_write;
if (is_segcompaction) {
- writer->reset(new segment_v2::SegmentWriter(file_writer.get(), _num_segcompacted,
- _context.tablet_schema, _context.data_dir,
- _context.max_rows_per_segment, writer_options));
+ writer->reset(new segment_v2::SegmentWriter(
+ file_writer.get(), _num_segcompacted, _context.tablet_schema, _context.tablet,
+ _context.data_dir, _context.max_rows_per_segment, writer_options,
+ _context.mow_context));
if (_segcompaction_worker.get_file_writer() != nullptr) {
_segcompaction_worker.get_file_writer()->close();
}
_segcompaction_worker.get_file_writer().reset(file_writer.release());
} else {
- writer->reset(new segment_v2::SegmentWriter(file_writer.get(), segment_id,
- _context.tablet_schema, _context.data_dir,
- _context.max_rows_per_segment, writer_options));
+ writer->reset(new segment_v2::SegmentWriter(
+ file_writer.get(), segment_id, _context.tablet_schema, _context.tablet,
+ _context.data_dir, _context.max_rows_per_segment, writer_options,
+ _context.mow_context));
{
std::lock_guard<SpinLock> l(_lock);
_file_writers.push_back(std::move(file_writer));
diff --git a/be/src/olap/rowset/beta_rowset_writer.h b/be/src/olap/rowset/beta_rowset_writer.h
index c6fa740a58..011e53e300 100644
--- a/be/src/olap/rowset/beta_rowset_writer.h
+++ b/be/src/olap/rowset/beta_rowset_writer.h
@@ -152,12 +152,15 @@ private:
Status _rename_compacted_segment_plain(uint64_t seg_id);
Status _rename_compacted_indices(int64_t begin, int64_t end, uint64_t seg_id);
+ void set_segment_start_id(int32_t start_id) override { _segment_start_id = start_id; }
+
protected:
RowsetWriterContext _context;
std::shared_ptr<RowsetMeta> _rowset_meta;
std::atomic<int32_t> _num_segment;
std::atomic<int32_t> _num_flushed_segment;
+ int32_t _segment_start_id; //basic write start from 0, partial update may be different
std::atomic<int32_t> _segcompacted_point; // segemnts before this point have
// already been segment compacted
std::atomic<int32_t> _num_segcompacted; // index for segment compaction
@@ -210,6 +213,8 @@ protected:
std::atomic<int> _segcompaction_status;
fmt::memory_buffer vlog_buffer;
+
+ std::shared_ptr<MowContext> _mow_context;
};
} // namespace doris
diff --git a/be/src/olap/rowset/rowset.cpp b/be/src/olap/rowset/rowset.cpp
index d9aa8fb05e..699d384b5f 100644
--- a/be/src/olap/rowset/rowset.cpp
+++ b/be/src/olap/rowset/rowset.cpp
@@ -83,4 +83,16 @@ bool Rowset::check_rowset_segment() {
return check_current_rowset_segment();
}
+void Rowset::merge_rowset_meta(const RowsetMetaSharedPtr& other) {
+ _rowset_meta->set_num_segments(num_segments() + other->num_segments());
+ _rowset_meta->set_num_rows(num_rows() + other->num_rows());
+ _rowset_meta->set_data_disk_size(data_disk_size() + other->data_disk_size());
+ _rowset_meta->set_index_disk_size(index_disk_size() + other->index_disk_size());
+ std::vector<KeyBoundsPB> key_bounds;
+ other->get_segments_key_bounds(&key_bounds);
+ for (auto key_bound : key_bounds) {
+ _rowset_meta->add_segment_key_bounds(key_bound);
+ }
+}
+
} // namespace doris
diff --git a/be/src/olap/rowset/rowset.h b/be/src/olap/rowset/rowset.h
index 198dd8a0cd..27fc38f398 100644
--- a/be/src/olap/rowset/rowset.h
+++ b/be/src/olap/rowset/rowset.h
@@ -166,6 +166,10 @@ public:
// TODO should we rename the method to remove_files() to be more specific?
virtual Status remove() = 0;
+ // used for partial update, when publish, partial update may add a new rowset
+ // and we should update rowset meta
+ void merge_rowset_meta(const RowsetMetaSharedPtr& other);
+
// close to clear the resource owned by rowset
// including: open files, indexes and so on
// NOTICE: can not call this function in multithreads
diff --git a/be/src/olap/rowset/rowset_meta.h b/be/src/olap/rowset/rowset_meta.h
index f9491e1553..5b7fbfface 100644
--- a/be/src/olap/rowset/rowset_meta.h
+++ b/be/src/olap/rowset/rowset_meta.h
@@ -355,6 +355,11 @@ public:
}
}
+ void add_segment_key_bounds(const KeyBoundsPB& segments_key_bounds) {
+ *_rowset_meta_pb.add_segments_key_bounds() = segments_key_bounds;
+ set_segments_overlap(OVERLAPPING);
+ }
+
void set_newest_write_timestamp(int64_t timestamp) {
_rowset_meta_pb.set_newest_write_timestamp(timestamp);
}
diff --git a/be/src/olap/rowset/rowset_writer.h b/be/src/olap/rowset/rowset_writer.h
index 6249f01637..1bdc4daa2d 100644
--- a/be/src/olap/rowset/rowset_writer.h
+++ b/be/src/olap/rowset/rowset_writer.h
@@ -93,6 +93,8 @@ public:
virtual Status wait_flying_segcompaction() = 0;
+ virtual void set_segment_start_id(int num_segment) { LOG(FATAL) << "not supported!"; }
+
private:
DISALLOW_COPY_AND_ASSIGN(RowsetWriter);
};
diff --git a/be/src/olap/rowset/rowset_writer_context.h b/be/src/olap/rowset/rowset_writer_context.h
index 8d4fabfc88..e526f80158 100644
--- a/be/src/olap/rowset/rowset_writer_context.h
+++ b/be/src/olap/rowset/rowset_writer_context.h
@@ -89,6 +89,8 @@ struct RowsetWriterContext {
// for tracing local schema change record
std::shared_ptr<vectorized::schema_util::LocalSchemaChangeRecorder> schema_change_recorder =
nullptr;
+
+ std::shared_ptr<MowContext> mow_context;
};
} // namespace doris
diff --git a/be/src/olap/rowset/segment_v2/segment.cpp b/be/src/olap/rowset/segment_v2/segment.cpp
index 78eab64949..3434634479 100644
--- a/be/src/olap/rowset/segment_v2/segment.cpp
+++ b/be/src/olap/rowset/segment_v2/segment.cpp
@@ -338,11 +338,11 @@ Status Segment::new_inverted_index_iterator(const TabletColumn& tablet_column,
return Status::OK();
}
-Status Segment::lookup_row_key(const Slice& key, RowLocation* row_location) {
+Status Segment::lookup_row_key(const Slice& key, bool with_seq_col, RowLocation* row_location) {
RETURN_IF_ERROR(load_pk_index_and_bf());
bool has_seq_col = _tablet_schema->has_sequence_col();
size_t seq_col_length = 0;
- if (has_seq_col) {
+ if (has_seq_col && with_seq_col) {
seq_col_length = _tablet_schema->column(_tablet_schema->sequence_col_idx()).length() + 1;
}
Slice key_without_seq = Slice(key.get_data(), key.get_size() - seq_col_length);
diff --git a/be/src/olap/rowset/segment_v2/segment.h b/be/src/olap/rowset/segment_v2/segment.h
index bfb09eb1fd..f847982761 100644
--- a/be/src/olap/rowset/segment_v2/segment.h
+++ b/be/src/olap/rowset/segment_v2/segment.h
@@ -103,7 +103,7 @@ public:
return _pk_index_reader.get();
}
- Status lookup_row_key(const Slice& key, RowLocation* row_location);
+ Status lookup_row_key(const Slice& key, bool with_seq_col, RowLocation* row_location);
Status read_key_by_rowid(uint32_t row_id, std::string* key);
diff --git a/be/src/olap/rowset/segment_v2/segment_writer.cpp b/be/src/olap/rowset/segment_v2/segment_writer.cpp
index 6b3a2a1039..7c430f5a07 100644
--- a/be/src/olap/rowset/segment_v2/segment_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/segment_writer.cpp
@@ -50,25 +50,33 @@
#include "vec/common/schema_util.h"
#include "vec/core/block.h"
#include "vec/core/column_with_type_and_name.h"
+#include "vec/io/reader_buffer.h"
+#include "vec/jsonb/serialize.h"
#include "vec/olap/olap_data_convertor.h"
namespace doris {
namespace segment_v2 {
+using namespace ErrorCode;
+
const char* k_segment_magic = "D0R1";
const uint32_t k_segment_magic_length = 4;
SegmentWriter::SegmentWriter(io::FileWriter* file_writer, uint32_t segment_id,
- TabletSchemaSPtr tablet_schema, DataDir* data_dir,
- uint32_t max_row_per_segment, const SegmentWriterOptions& opts)
+ TabletSchemaSPtr tablet_schema, TabletSharedPtr tablet,
+ DataDir* data_dir, uint32_t max_row_per_segment,
+ const SegmentWriterOptions& opts,
+ std::shared_ptr<MowContext> mow_context)
: _segment_id(segment_id),
_tablet_schema(tablet_schema),
+ _tablet(tablet),
_data_dir(data_dir),
_max_row_per_segment(max_row_per_segment),
_opts(opts),
_file_writer(file_writer),
_mem_tracker(std::make_unique<MemTracker>("SegmentWriter:Segment-" +
- std::to_string(segment_id))) {
+ std::to_string(segment_id))),
+ _mow_context(mow_context) {
CHECK_NOTNULL(file_writer);
_num_key_columns = _tablet_schema->num_key_columns();
_num_short_key_columns = _tablet_schema->num_short_key_columns();
@@ -108,7 +116,8 @@ void SegmentWriter::init_column_meta(ColumnMetaPB* meta, uint32_t column_id,
Status SegmentWriter::init(const vectorized::Block* block) {
std::vector<uint32_t> column_ids;
int column_cnt = _tablet_schema->num_columns();
- if (block) {
+ if (block && !_tablet_schema->is_partial_update()) {
+ // partial update only contain several columns
column_cnt = block->columns();
}
for (uint32_t i = 0; i < column_cnt; ++i) {
@@ -297,11 +306,230 @@ void SegmentWriter::_maybe_invalid_row_cache(const std::string& key) {
}
}
+void SegmentWriter::_serialize_block_to_row_column(vectorized::Block& block) {
+ if (block.rows() == 0) {
+ return;
+ }
+ MonotonicStopWatch watch;
+ watch.start();
+ // find row column id
+ int row_column_id = 0;
+ for (int i = 0; i < _tablet_schema->num_columns(); ++i) {
+ if (_tablet_schema->column(i).is_row_store_column()) {
+ row_column_id = i;
+ break;
+ }
+ }
+ vectorized::ColumnString* row_store_column =
+ static_cast<vectorized::ColumnString*>(block.get_by_position(row_column_id)
+ .column->assume_mutable_ref()
+ .assume_mutable()
+ .get());
+ row_store_column->clear();
+ vectorized::JsonbSerializeUtil::block_to_jsonb(*_tablet_schema, block, *row_store_column,
+ _tablet_schema->num_columns());
+ VLOG_DEBUG << "serialize , num_rows:" << block.rows() << ", row_column_id:" << row_column_id
+ << ", total_byte_size:" << block.allocated_bytes() << ", serialize_cost(us)"
+ << watch.elapsed_time() / 1000;
+}
+
+// for partial update, we should do following steps to fill content of block:
+// 1. set block data to data convertor, and get all key_column's converted slice
+// 2. get pk of input block, and read missing columns
+// 2.1 first find key location{rowset_id, segment_id, row_id}
+// 2.2 build read plan to read by batch
+// 2.3 fill block
+// 3. set columns to data convertor and then write all columns
+Status SegmentWriter::append_block_with_partial_content(const vectorized::Block* block,
+ size_t row_pos, size_t num_rows) {
+ CHECK(block->columns() > _tablet_schema->num_key_columns() &&
+ block->columns() < _tablet_schema->num_columns());
+ CHECK(_tablet_schema->keys_type() == UNIQUE_KEYS && _opts.enable_unique_key_merge_on_write);
+
+ // find missing column cids
+ std::vector<uint32_t> missing_cids;
+ std::vector<uint32_t> including_cids;
+ for (uint32_t i = 0; i < _tablet_schema->num_columns(); ++i) {
+ if (_tablet_schema->is_column_missing(i)) {
+ missing_cids.push_back(i);
+ } else {
+ including_cids.push_back(i);
+ }
+ }
+ // create full block and fill with input columns
+ auto full_block = _tablet_schema->create_block();
+ size_t input_id = 0;
+ for (auto i : including_cids) {
+ full_block.replace_by_position(i, block->get_by_position(input_id++).column);
+ }
+ _olap_data_convertor->set_source_content_with_specifid_columns(&full_block, row_pos, num_rows,
+ including_cids);
+
+ // write including columns
+ std::vector<vectorized::IOlapColumnDataAccessor*> key_columns;
+ for (auto cid : including_cids) {
+ // olap data convertor alway start from id = 0
+ auto converted_result = _olap_data_convertor->convert_column_data(cid);
+ if (converted_result.first != Status::OK()) {
+ return converted_result.first;
+ }
+ if (cid < _num_key_columns) {
+ key_columns.push_back(converted_result.second);
+ }
+ RETURN_IF_ERROR(_column_writers[cid]->append(converted_result.second->get_nullmap(),
+ converted_result.second->get_data(),
+ num_rows));
+ }
+
+ bool has_default = false;
+ std::vector<bool> use_default_flag;
+ use_default_flag.reserve(num_rows);
+ for (size_t pos = 0; pos < num_rows; pos++) {
+ std::string key = _full_encode_keys(key_columns, pos);
+ RETURN_IF_ERROR(_primary_key_index_builder->add_item(key));
+ _maybe_invalid_row_cache(key);
+
+ RowLocation loc;
+ // save rowset shared ptr so this rowset wouldn't delete
+ RowsetSharedPtr rowset;
+ auto st = _tablet->lookup_row_key(key, false, &_mow_context->rowset_ids, &loc,
+ _mow_context->max_version, &rowset);
+ if (st.is<NOT_FOUND>()) {
+ if (!_tablet_schema->allow_key_not_exist_in_partial_update()) {
+ return Status::InternalError("partial update key not exist before");
+ }
+ has_default = true;
+ use_default_flag.emplace_back(true);
+ continue;
+ }
+ if (!st.ok()) {
+ LOG(WARNING) << "failed to lookup row key";
+ return st;
+ }
+ // partial update should not contain invisible columns
+ use_default_flag.emplace_back(false);
+ _rsid_to_rowset.emplace(rowset->rowset_id(), rowset);
+ _tablet->prepare_to_read(loc, pos, &_rssid_to_rid);
+ _mow_context->delete_bitmap->add({loc.rowset_id, loc.segment_id, 0}, loc.row_id);
+ }
+ CHECK(use_default_flag.size() == num_rows);
+
+ // read and fill block
+ auto mutable_full_columns = full_block.mutate_columns();
+ RETURN_IF_ERROR(fill_missing_columns(mutable_full_columns, use_default_flag, has_default));
+ // row column should be filled here
+ if (_tablet_schema->store_row_column()) {
+ // convert block to row store format
+ _serialize_block_to_row_column(full_block);
+ }
+
+ // convert missing columns and send to column writer
+ auto cids_missing = _tablet_schema->get_missing_cids();
+ _olap_data_convertor->set_source_content_with_specifid_columns(&full_block, row_pos, num_rows,
+ cids_missing);
+ for (auto cid : cids_missing) {
+ auto converted_result = _olap_data_convertor->convert_column_data(cid);
+ if (converted_result.first != Status::OK()) {
+ return converted_result.first;
+ }
+ RETURN_IF_ERROR(_column_writers[cid]->append(converted_result.second->get_nullmap(),
+ converted_result.second->get_data(),
+ num_rows));
+ }
+
+ _num_rows_written += num_rows;
+ _olap_data_convertor->clear_source_content();
+ return Status::OK();
+}
+
+Status SegmentWriter::fill_missing_columns(vectorized::MutableColumns& mutable_full_columns,
+ const std::vector<bool>& use_default_flag,
+ bool has_default) {
+ // create old value columns
+ auto old_value_block = _tablet_schema->create_missing_columns_block();
+ std::vector<uint32_t> cids_missing = _tablet_schema->get_missing_cids();
+ CHECK(cids_missing.size() == old_value_block.columns());
+ auto mutable_old_columns = old_value_block.mutate_columns();
+ bool has_row_column = _tablet_schema->store_row_column();
+ // record real pos, key is input line num, value is old_block line num
+ std::map<uint32_t, uint32_t> read_index;
+ size_t read_idx = 0;
+ for (auto rs_it : _rssid_to_rid) {
+ for (auto seg_it : rs_it.second) {
+ auto rowset = _rsid_to_rowset[rs_it.first];
+ CHECK(rowset);
+ std::vector<uint32_t> rids;
+ for (auto id_and_pos : seg_it.second) {
+ rids.emplace_back(id_and_pos.rid);
+ read_index[id_and_pos.pos] = read_idx++;
+ }
+ if (has_row_column) {
+ auto st = _tablet->fetch_value_through_row_column(rowset, seg_it.first, rids,
+ cids_missing, old_value_block);
+ if (!st.ok()) {
+ LOG(WARNING) << "failed to fetch value through row column";
+ return st;
+ }
+ continue;
+ }
+ for (size_t cid = 0; cid < mutable_old_columns.size(); ++cid) {
+ auto st = _tablet->fetch_value_by_rowids(rowset, seg_it.first, rids,
+ old_value_block.get_names()[cid],
+ mutable_old_columns[cid]);
+ // set read value to output block
+ if (!st.ok()) {
+ LOG(WARNING) << "failed to fetch value by rowids";
+ return st;
+ }
+ }
+ }
+ }
+ // build default value columns
+ auto default_value_block = old_value_block.clone_empty();
+ auto mutable_default_value_columns = default_value_block.mutate_columns();
+ if (has_default) {
+ for (auto i = 0; i < cids_missing.size(); ++i) {
+ auto default_value = _tablet_schema->column(cids_missing[i]).default_value();
+ vectorized::ReadBuffer rb(const_cast<char*>(default_value.c_str()),
+ default_value.size());
+ old_value_block.get_by_position(i).type->from_string(
+ rb, mutable_default_value_columns[i].get());
+ }
+ }
+
+ // fill all missing value from mutable_old_columns, need consider default value
+ for (auto idx = 0; idx < use_default_flag.size(); idx++) {
+ if (use_default_flag[idx]) {
+ // use default value
+ for (auto i = 0; i < cids_missing.size(); ++i) {
+ CHECK(_tablet_schema->column(cids_missing[i]).has_default_value());
+ mutable_full_columns[cids_missing[i]]->insert_from(
+ *mutable_default_value_columns[i].get(), 0);
+ }
+ continue;
+ }
+ auto pos_in_old_block = read_index[idx];
+ for (auto i = 0; i < cids_missing.size(); ++i) {
+ mutable_full_columns[cids_missing[i]]->insert_from(
+ *old_value_block.get_columns_with_type_and_name()[i].column.get(),
+ pos_in_old_block);
+ }
+ }
+ return Status::OK();
+}
+
Status SegmentWriter::append_block(const vectorized::Block* block, size_t row_pos,
size_t num_rows) {
+ if (_tablet_schema->is_partial_update() && _opts.is_direct_write) {
+ RETURN_IF_ERROR(append_block_with_partial_content(block, row_pos, num_rows));
+ return Status::OK();
+ }
CHECK(block->columns() >= _column_writers.size())
<< ", block->columns()=" << block->columns()
<< ", _column_writers.size()=" << _column_writers.size();
+ if (_tablet_schema->store_row_column() && _opts.is_direct_write) {
+ _serialize_block_to_row_column(*const_cast<vectorized::Block*>(block));
+ }
_olap_data_convertor->set_source_content(block, row_pos, num_rows);
@@ -705,5 +933,9 @@ void SegmentWriter::set_max_key(const Slice& key) {
_max_key.append(key.get_data(), key.get_size());
}
+void SegmentWriter::set_mow_context(std::shared_ptr<MowContext> mow_context) {
+ _mow_context = mow_context;
+}
+
} // namespace segment_v2
} // namespace doris
diff --git a/be/src/olap/rowset/segment_v2/segment_writer.h b/be/src/olap/rowset/segment_v2/segment_writer.h
index c907a357df..e66ae33d43 100644
--- a/be/src/olap/rowset/segment_v2/segment_writer.h
+++ b/be/src/olap/rowset/segment_v2/segment_writer.h
@@ -24,15 +24,19 @@
#include <cstdint>
#include <functional>
+#include <map>
#include <memory> // unique_ptr
#include <string>
#include <unordered_set>
#include <vector>
#include "common/status.h" // Status
+#include "gen_cpp/segment_v2.pb.h"
+#include "gutil/macros.h"
#include "gutil/strings/substitute.h"
#include "olap/olap_define.h"
#include "olap/rowset/segment_v2/column_writer.h"
+#include "olap/tablet.h"
#include "olap/tablet_schema.h"
#include "util/faststring.h"
#include "util/slice.h"
@@ -75,11 +79,15 @@ struct SegmentWriterOptions {
bool is_direct_write = false;
};
+using TabletSharedPtr = std::shared_ptr<Tablet>;
+
class SegmentWriter {
public:
explicit SegmentWriter(io::FileWriter* file_writer, uint32_t segment_id,
- TabletSchemaSPtr tablet_schema, DataDir* data_dir,
- uint32_t max_row_per_segment, const SegmentWriterOptions& opts);
+ TabletSchemaSPtr tablet_schema, TabletSharedPtr tablet,
+ DataDir* data_dir, uint32_t max_row_per_segment,
+ const SegmentWriterOptions& opts,
+ std::shared_ptr<MowContext> mow_context);
~SegmentWriter();
Status init(const vectorized::Block* block = nullptr);
@@ -92,6 +100,8 @@ public:
Status append_row(const RowType& row);
Status append_block(const vectorized::Block* block, size_t row_pos, size_t num_rows);
+ Status append_block_with_partial_content(const vectorized::Block* block, size_t row_pos,
+ size_t num_rows);
int64_t max_row_to_add(size_t row_avg_size_in_bytes);
@@ -121,6 +131,10 @@ public:
void clear();
+ void set_mow_context(std::shared_ptr<MowContext> mow_context);
+ Status fill_missing_columns(vectorized::MutableColumns& mutable_full_columns,
+ const std::vector<bool>& use_default_flag, bool has_default);
+
private:
Status _create_writers_with_dynamic_block(
const vectorized::Block* block,
@@ -151,10 +165,12 @@ private:
void set_min_key(const Slice& key);
void set_max_key(const Slice& key);
bool _should_create_writers_with_dynamic_block(size_t num_columns_in_block);
+ void _serialize_block_to_row_column(vectorized::Block& block);
private:
uint32_t _segment_id;
TabletSchemaSPtr _tablet_schema;
+ TabletSharedPtr _tablet;
DataDir* _data_dir;
uint32_t _max_row_per_segment;
SegmentWriterOptions _opts;
@@ -191,6 +207,13 @@ private:
bool _is_first_row = true;
faststring _min_key;
faststring _max_key;
+
+ std::shared_ptr<MowContext> _mow_context;
+ // group every rowset-segment row id to speed up reader
+ PartialUpdateReadPlan _rssid_to_rid;
+ std::map<RowsetId, RowsetSharedPtr> _rsid_to_rowset;
+
+ // record row locations here and used when memtable flush
};
} // namespace segment_v2
diff --git a/be/src/olap/rowset/vertical_beta_rowset_writer.cpp b/be/src/olap/rowset/vertical_beta_rowset_writer.cpp
index 6525407a91..9df66651b0 100644
--- a/be/src/olap/rowset/vertical_beta_rowset_writer.cpp
+++ b/be/src/olap/rowset/vertical_beta_rowset_writer.cpp
@@ -172,9 +172,9 @@ Status VerticalBetaRowsetWriter::_create_segment_writer(
segment_v2::SegmentWriterOptions writer_options;
writer_options.enable_unique_key_merge_on_write = _context.enable_unique_key_merge_on_write;
writer_options.rowset_ctx = &_context;
- writer->reset(new segment_v2::SegmentWriter(file_writer.get(), _num_segment,
- _context.tablet_schema, _context.data_dir,
- _context.max_rows_per_segment, writer_options));
+ writer->reset(new segment_v2::SegmentWriter(
+ file_writer.get(), _num_segment, _context.tablet_schema, _context.tablet,
+ _context.data_dir, _context.max_rows_per_segment, writer_options, nullptr));
{
std::lock_guard<SpinLock> l(_lock);
_file_writers.push_back(std::move(file_writer));
diff --git a/be/src/olap/segment_loader.cpp b/be/src/olap/segment_loader.cpp
index eaf6651fc5..f244f2bb71 100644
--- a/be/src/olap/segment_loader.cpp
+++ b/be/src/olap/segment_loader.cpp
@@ -88,6 +88,10 @@ Status SegmentLoader::load_segments(const BetaRowsetSharedPtr& rowset,
return Status::OK();
}
+void SegmentLoader::erase_segment(const SegmentLoader::CacheKey& key) {
+ _cache->erase(key.encode());
+}
+
Status SegmentLoader::prune() {
const int64_t curtime = UnixMillis();
auto pred = [curtime](const void* value) -> bool {
diff --git a/be/src/olap/segment_loader.h b/be/src/olap/segment_loader.h
index 13da58a2e5..292b5df988 100644
--- a/be/src/olap/segment_loader.h
+++ b/be/src/olap/segment_loader.h
@@ -93,6 +93,8 @@ public:
Status load_segments(const BetaRowsetSharedPtr& rowset, SegmentCacheHandle* cache_handle,
bool use_cache = false);
+ void erase_segment(const SegmentLoader::CacheKey& key);
+
// Try to prune the segment cache if expired.
Status prune();
int64_t prune_all() { return _cache->prune(); };
diff --git a/be/src/olap/tablet.cpp b/be/src/olap/tablet.cpp
index 96311c4c77..75b2824849 100644
--- a/be/src/olap/tablet.cpp
+++ b/be/src/olap/tablet.cpp
@@ -75,6 +75,7 @@
#include "olap/base_tablet.h"
#include "olap/cumulative_compaction.h"
#include "olap/cumulative_compaction_policy.h"
+#include "olap/memtable.h"
#include "olap/olap_common.h"
#include "olap/olap_define.h"
#include "olap/olap_meta.h"
@@ -1769,18 +1770,27 @@ Status Tablet::create_initial_rowset(const int64_t req_version) {
Status Tablet::create_vertical_rowset_writer(RowsetWriterContext& context,
std::unique_ptr<RowsetWriter>* rowset_writer) {
+ context.rowset_id = StorageEngine::instance()->next_rowset_id();
_init_context_common_fields(context);
return RowsetFactory::create_rowset_writer(context, true, rowset_writer);
}
Status Tablet::create_rowset_writer(RowsetWriterContext& context,
std::unique_ptr<RowsetWriter>* rowset_writer) {
+ context.rowset_id = StorageEngine::instance()->next_rowset_id();
+ _init_context_common_fields(context);
+ return RowsetFactory::create_rowset_writer(context, false, rowset_writer);
+}
+
+Status Tablet::create_transient_rowset_writer(RowsetWriterContext& context,
+ const RowsetId& rowset_id,
+ std::unique_ptr<RowsetWriter>* rowset_writer) {
+ context.rowset_id = rowset_id;
_init_context_common_fields(context);
return RowsetFactory::create_rowset_writer(context, false, rowset_writer);
}
void Tablet::_init_context_common_fields(RowsetWriterContext& context) {
- context.rowset_id = StorageEngine::instance()->next_rowset_id();
context.tablet_uid = tablet_uid();
context.tablet_id = tablet_id();
@@ -2378,6 +2388,97 @@ TabletSchemaSPtr Tablet::get_max_version_schema(std::lock_guard<std::shared_mute
return _max_version_schema;
}
+// fetch value by row column
+Status Tablet::fetch_value_through_row_column(RowsetSharedPtr input_rowset, uint32_t segid,
+ const std::vector<uint32_t>& rowids,
+ const std::vector<uint32_t>& cids,
+ vectorized::Block& block) {
+ // read row data
+ BetaRowsetSharedPtr rowset = std::static_pointer_cast<BetaRowset>(input_rowset);
+ CHECK(rowset);
+
+ const TabletSchemaSPtr tablet_schema = rowset->tablet_schema();
+ SegmentCacheHandle segment_cache;
+ RETURN_IF_ERROR(SegmentLoader::instance()->load_segments(rowset, &segment_cache, true));
+ // find segment
+ auto it = std::find_if(
+ segment_cache.get_segments().begin(), segment_cache.get_segments().end(),
+ [&segid](const segment_v2::SegmentSharedPtr& seg) { return seg->id() == segid; });
+ if (it == segment_cache.get_segments().end()) {
+ return Status::NotFound(fmt::format("rowset {} 's segemnt not found, seg_id {}",
+ rowset->rowset_id().to_string(), segid));
+ }
+ // read from segment column by column, row by row
+ segment_v2::SegmentSharedPtr segment = *it;
+ MonotonicStopWatch watch;
+ watch.start();
+ Defer _defer([&]() {
+ LOG_EVERY_N(INFO, 500) << "fetch_value_by_rowids, cost(us):" << watch.elapsed_time() / 1000
+ << ", row_batch_size:" << rowids.size();
+ });
+ CHECK(tablet_schema->store_row_column());
+ // create _source column
+ segment_v2::ColumnIterator* column_iterator = nullptr;
+ RETURN_IF_ERROR(segment->new_column_iterator(tablet_schema->column(BeConsts::ROW_STORE_COL),
+ &column_iterator));
+ std::unique_ptr<segment_v2::ColumnIterator> ptr_guard(column_iterator);
+ segment_v2::ColumnIteratorOptions opt;
+ OlapReaderStatistics stats;
+ opt.file_reader = segment->file_reader().get();
+ opt.stats = &stats;
+ opt.use_page_cache = !config::disable_storage_page_cache;
+ column_iterator->init(opt);
+ // get and parse tuple row
+ vectorized::MutableColumnPtr column_ptr = vectorized::ColumnString::create();
+ RETURN_IF_ERROR(column_iterator->read_by_rowids(rowids.data(), rowids.size(), column_ptr));
+ assert(column_ptr->size() == rowids.size());
+ auto string_column = static_cast<vectorized::ColumnString*>(column_ptr.get());
+ vectorized::JsonbSerializeUtil::jsonb_to_block(tablet_schema, cids, *string_column, block);
+ return Status::OK();
+}
+
+Status Tablet::fetch_value_by_rowids(RowsetSharedPtr input_rowset, uint32_t segid,
+ const std::vector<uint32_t>& rowids,
+ const std::string& column_name,
+ vectorized::MutableColumnPtr& dst) {
+ // read row data
+ BetaRowsetSharedPtr rowset = std::static_pointer_cast<BetaRowset>(input_rowset);
+ CHECK(rowset);
+
+ const TabletSchemaSPtr tablet_schema = rowset->tablet_schema();
+ SegmentCacheHandle segment_cache;
+ RETURN_IF_ERROR(SegmentLoader::instance()->load_segments(rowset, &segment_cache, true));
+ // find segment
+ auto it = std::find_if(
+ segment_cache.get_segments().begin(), segment_cache.get_segments().end(),
+ [&segid](const segment_v2::SegmentSharedPtr& seg) { return seg->id() == segid; });
+ if (it == segment_cache.get_segments().end()) {
+ return Status::NotFound(fmt::format("rowset {} 's segemnt not found, seg_id {}",
+ rowset->rowset_id().to_string(), segid));
+ }
+ // read from segment column by column, row by row
+ segment_v2::SegmentSharedPtr segment = *it;
+ MonotonicStopWatch watch;
+ watch.start();
+ Defer _defer([&]() {
+ LOG_EVERY_N(INFO, 500) << "fetch_value_by_rowids, cost(us):" << watch.elapsed_time() / 1000
+ << ", row_batch_size:" << rowids.size();
+ });
+ // create _source column
+ segment_v2::ColumnIterator* column_iterator = nullptr;
+ RETURN_IF_ERROR(
+ segment->new_column_iterator(tablet_schema->column(column_name), &column_iterator));
+ std::unique_ptr<segment_v2::ColumnIterator> ptr_guard(column_iterator);
+ segment_v2::ColumnIteratorOptions opt;
+ OlapReaderStatistics stats;
+ opt.file_reader = segment->file_reader().get();
+ opt.stats = &stats;
+ opt.use_page_cache = !config::disable_storage_page_cache;
+ column_iterator->init(opt);
+ RETURN_IF_ERROR(column_iterator->read_by_rowids(rowids.data(), rowids.size(), dst));
+ return Status::OK();
+}
+
Status Tablet::lookup_row_data(const Slice& encoded_key, const RowLocation& row_location,
RowsetSharedPtr input_rowset, const TupleDescriptor* desc,
OlapReaderStatistics& stats, vectorized::Block* block,
@@ -2411,41 +2512,37 @@ Status Tablet::lookup_row_data(const Slice& encoded_key, const RowLocation& row_
LOG_EVERY_N(INFO, 500) << "get a single_row, cost(us):" << watch.elapsed_time() / 1000
<< ", row_size:" << row_size;
});
- if (tablet_schema->store_row_column()) {
- // create _source column
- segment_v2::ColumnIterator* column_iterator = nullptr;
- RETURN_IF_ERROR(segment->new_column_iterator(tablet_schema->column(BeConsts::ROW_STORE_COL),
- &column_iterator));
- std::unique_ptr<segment_v2::ColumnIterator> ptr_guard(column_iterator);
- segment_v2::ColumnIteratorOptions opt;
- opt.file_reader = segment->file_reader().get();
- opt.stats = &stats;
- opt.use_page_cache = !config::disable_storage_page_cache;
- column_iterator->init(opt);
- // get and parse tuple row
- vectorized::MutableColumnPtr column_ptr = vectorized::ColumnString::create();
- std::vector<segment_v2::rowid_t> rowids {
- static_cast<segment_v2::rowid_t>(row_location.row_id)};
- RETURN_IF_ERROR(column_iterator->read_by_rowids(rowids.data(), 1, column_ptr));
- assert(column_ptr->size() == 1);
- auto string_column = static_cast<vectorized::ColumnString*>(column_ptr.get());
- if (write_to_cache) {
- StringRef value = string_column->get_data_at(0);
- RowCache::instance()->insert({tablet_id(), encoded_key},
- Slice {value.data, value.size});
- }
- vectorized::JsonbSerializeUtil::jsonb_to_block(*desc, *string_column, *block);
- return Status::OK();
- }
- __builtin_unreachable();
+ CHECK(tablet_schema->store_row_column());
+ // create _source column
+ segment_v2::ColumnIterator* column_iterator = nullptr;
+ RETURN_IF_ERROR(segment->new_column_iterator(tablet_schema->column(BeConsts::ROW_STORE_COL),
+ &column_iterator));
+ std::unique_ptr<segment_v2::ColumnIterator> ptr_guard(column_iterator);
+ segment_v2::ColumnIteratorOptions opt;
+ opt.file_reader = segment->file_reader().get();
+ opt.stats = &stats;
+ opt.use_page_cache = !config::disable_storage_page_cache;
+ column_iterator->init(opt);
+ // get and parse tuple row
+ vectorized::MutableColumnPtr column_ptr = vectorized::ColumnString::create();
+ std::vector<segment_v2::rowid_t> rowids {static_cast<segment_v2::rowid_t>(row_location.row_id)};
+ RETURN_IF_ERROR(column_iterator->read_by_rowids(rowids.data(), 1, column_ptr));
+ assert(column_ptr->size() == 1);
+ auto string_column = static_cast<vectorized::ColumnString*>(column_ptr.get());
+ if (write_to_cache) {
+ StringRef value = string_column->get_data_at(0);
+ RowCache::instance()->insert({tablet_id(), encoded_key}, Slice {value.data, value.size});
+ }
+ vectorized::JsonbSerializeUtil::jsonb_to_block(*desc, *string_column, *block);
+ return Status::OK();
}
-Status Tablet::lookup_row_key(const Slice& encoded_key, const RowsetIdUnorderedSet* rowset_ids,
- RowLocation* row_location, uint32_t version,
- RowsetSharedPtr* rowset) {
+Status Tablet::lookup_row_key(const Slice& encoded_key, bool with_seq_col,
+ const RowsetIdUnorderedSet* rowset_ids, RowLocation* row_location,
+ uint32_t version, RowsetSharedPtr* rowset) {
std::vector<std::pair<RowsetSharedPtr, int32_t>> selected_rs;
size_t seq_col_length = 0;
- if (_schema->has_sequence_col()) {
+ if (_schema->has_sequence_col() && with_seq_col) {
seq_col_length = _schema->column(_schema->sequence_col_idx()).length() + 1;
}
Slice key_without_seq = Slice(encoded_key.get_data(), encoded_key.get_size() - seq_col_length);
@@ -2472,7 +2569,7 @@ Status Tablet::lookup_row_key(const Slice& encoded_key, const RowsetIdUnorderedS
std::static_pointer_cast<BetaRowset>(rs.first), &segment_cache_handle, true));
auto& segments = segment_cache_handle.get_segments();
DCHECK_GT(segments.size(), rs.second);
- Status s = segments[rs.second]->lookup_row_key(encoded_key, &loc);
+ Status s = segments[rs.second]->lookup_row_key(encoded_key, with_seq_col, &loc);
if (s.is<NOT_FOUND>()) {
continue;
}
@@ -2509,16 +2606,69 @@ Status Tablet::_load_rowset_segments(const RowsetSharedPtr& rowset,
return Status::OK();
}
+void Tablet::sort_block(vectorized::Block& in_block, vectorized::Block& output_block) {
+ vectorized::MutableBlock mutable_input_block =
+ vectorized::MutableBlock::build_mutable_block(&in_block);
+ vectorized::MutableBlock mutable_output_block =
+ vectorized::MutableBlock::build_mutable_block(&output_block);
+
+ std::vector<RowInBlock*> _row_in_blocks;
+ _row_in_blocks.reserve(in_block.rows());
+
+ std::unique_ptr<Schema> schema(new Schema(_schema));
+ std::shared_ptr<RowInBlockComparator> vec_row_comparator =
+ std::make_shared<RowInBlockComparator>(schema.get());
+ vec_row_comparator->set_block(&mutable_input_block);
+
+ std::vector<RowInBlock*> row_in_blocks;
+ DCHECK(in_block.rows() <= std::numeric_limits<int>::max());
+ row_in_blocks.reserve(in_block.rows());
+ for (size_t i = 0; i < in_block.rows(); ++i) {
+ row_in_blocks.emplace_back(new RowInBlock {i});
+ }
+ std::sort(row_in_blocks.begin(), row_in_blocks.end(),
+ [&](const RowInBlock* l, const RowInBlock* r) -> bool {
+ auto value = (*vec_row_comparator)(l, r);
+ DCHECK(value != 0) << "value equel when sort block, l_pos: " << l->_row_pos
+ << " r_pos: " << r->_row_pos;
+ return value < 0;
+ });
+ std::vector<int> row_pos_vec;
+ row_pos_vec.reserve(in_block.rows());
+ for (int i = 0; i < row_in_blocks.size(); i++) {
+ row_pos_vec.emplace_back(row_in_blocks[i]->_row_pos);
+ }
+ mutable_output_block.add_rows(&in_block, row_pos_vec.data(),
+ row_pos_vec.data() + in_block.rows());
+}
+
// caller should hold meta_lock
-Status Tablet::calc_delete_bitmap(RowsetId rowset_id,
+Status Tablet::calc_delete_bitmap(RowsetSharedPtr rowset,
const std::vector<segment_v2::SegmentSharedPtr>& segments,
const RowsetIdUnorderedSet* specified_rowset_ids,
DeleteBitmapPtr delete_bitmap, int64_t end_version,
- bool check_pre_segments) {
+ bool check_pre_segments, RowsetWriter* rowset_writer) {
std::vector<segment_v2::SegmentSharedPtr> pre_segments;
OlapStopWatch watch;
Version dummy_version(end_version + 1, end_version + 1);
+ auto rowset_id = rowset->rowset_id();
+ auto rowset_schema = rowset->tablet_schema();
+ bool is_partial_update = rowset_schema->is_partial_update();
+ // use for partial update
+ PartialUpdateReadPlan read_plan_ori;
+ PartialUpdateReadPlan read_plan_update;
+
+ std::map<RowsetId, RowsetSharedPtr> rsid_to_rowset;
+ rsid_to_rowset[rowset_id] = rowset;
+ vectorized::Block block = rowset_schema->create_block();
+ vectorized::Block ordered_block = block.clone_empty();
+ uint32_t pos = 0;
+ auto segment_row_max = 0;
+ if (segments.size() > 0) {
+ segment_row_max = segments[0]->num_rows();
+ }
+
for (auto& seg : segments) {
seg->load_pk_index_and_bf(); // We need index blocks to iterate
auto pk_idx = seg->get_primary_key_index();
@@ -2553,6 +2703,8 @@ Status Tablet::calc_delete_bitmap(RowsetId rowset_id,
Slice(index_column->get_data_at(i).data, index_column->get_data_at(i).size);
RowLocation loc;
// first check if exist in pre segment
+ // same rowset can ignore partial update, every load must update same columns
+ // so last segment must contain newest data
if (check_pre_segments) {
auto st = _check_pk_in_pre_segments(rowset_id, pre_segments, key, delete_bitmap,
&loc);
@@ -2566,10 +2718,15 @@ Status Tablet::calc_delete_bitmap(RowsetId rowset_id,
continue;
}
}
+ // same row in segments should be filtered
+ if (delete_bitmap->contains({rowset_id, seg->id(), 0}, row_id)) {
+ continue;
+ }
if (specified_rowset_ids != nullptr && !specified_rowset_ids->empty()) {
- auto st = lookup_row_key(key, specified_rowset_ids, &loc,
- dummy_version.first - 1);
+ RowsetSharedPtr rowset_find;
+ auto st = lookup_row_key(key, true, specified_rowset_ids, &loc,
+ dummy_version.first - 1, &rowset_find);
bool expected_st = st.ok() || st.is<NOT_FOUND>() || st.is<ALREADY_EXIST>();
DCHECK(expected_st) << "unexpected error status while lookup_row_key:" << st;
if (!expected_st) {
@@ -2582,19 +2739,49 @@ Status Tablet::calc_delete_bitmap(RowsetId rowset_id,
// sequence id smaller than the previous one, so delete current row
if (st.is<ALREADY_EXIST>()) {
- loc.rowset_id = rowset_id;
- loc.segment_id = seg->id();
- loc.row_id = row_id;
+ delete_bitmap->add({rowset_id, seg->id(), 0}, row_id);
+ continue;
+ } else if (is_partial_update && rowset_writer != nullptr) {
+ // In publish version, record rows to be deleted for concurrent update
+ // For example, if version 5 and 6 update a row, but version 6 only see
+ // version 4 when write, and when publish version, version 5's value will
+ // be marked as deleted and it's update is losed.
+ // So here we should read version 5's columns and build a new row, which is
+ // consists of version 6's update columns and version 5's origin columns
+ // here we build 2 read plan for ori values and update values
+ prepare_to_read(loc, pos, &read_plan_ori);
+ prepare_to_read(RowLocation {rowset_id, seg->id(), row_id}, pos,
+ &read_plan_update);
+ rsid_to_rowset[rowset_find->rowset_id()] = rowset_find;
+ ++pos;
+ // sort segment rows here
+ if (pos >= segment_row_max) {
+ generate_new_block_for_partial_update(rowset_schema, read_plan_ori,
+ read_plan_update, rsid_to_rowset,
+ &block);
+ sort_block(block, ordered_block);
+ int64_t size;
+ rowset_writer->flush_single_memtable(&ordered_block, &size);
+ // clear all tmp data
+ read_plan_ori.clear();
+ read_plan_update.clear();
+ pos = 0;
+ block.clear_column_data();
+ ordered_block.clear_column_data();
+ }
+ // delete bitmap will be calculate when memtable flush and
+ // publish. The two stages may see different versions.
+ // When there is sequence column, the currently imported data
+ // of rowset may be marked for deletion at memtablet flush or
+ // publish because the seq column is smaller than the previous
+ // rowset.
+ // just set 0 as a unified temporary version number, and update to
+ // the real version number later.
+ delete_bitmap->add({loc.rowset_id, loc.segment_id, 0}, loc.row_id);
+ delete_bitmap->add({rowset_id, seg->id(), 0}, row_id);
+ continue;
}
-
- // delete bitmap will be calculate when memtable flush and
- // publish. The two stages may see different versions.
- // When there is sequence column, the currently imported data
- // of rowset may be marked for deletion at memtablet flush or
- // publish because the seq column is smaller than the previous
- // rowset.
- // just set 0 as a unified temporary version number, and update to
- // the real version number later.
+ // when st = ok
delete_bitmap->add({loc.rowset_id, loc.segment_id, 0}, loc.row_id);
}
++row_id;
@@ -2605,6 +2792,15 @@ Status Tablet::calc_delete_bitmap(RowsetId rowset_id,
pre_segments.emplace_back(seg);
}
}
+ // add last block for partial update
+ if (pos > 0) {
+ generate_new_block_for_partial_update(rowset_schema, read_plan_ori, read_plan_update,
+ rsid_to_rowset, &block);
+ sort_block(block, ordered_block);
+ int64_t size;
+ rowset_writer->flush_single_memtable(&ordered_block, &size);
+ }
+
LOG(INFO) << "construct delete bitmap tablet: " << tablet_id() << " rowset: " << rowset_id
<< " dummy_version: " << dummy_version
<< "bitmap num: " << delete_bitmap->delete_bitmap.size()
@@ -2612,11 +2808,120 @@ Status Tablet::calc_delete_bitmap(RowsetId rowset_id,
return Status::OK();
}
+Status Tablet::generate_new_block_for_partial_update(
+ TabletSchemaSPtr rowset_schema, const PartialUpdateReadPlan& read_plan_ori,
+ const PartialUpdateReadPlan& read_plan_update,
+ const std::map<RowsetId, RowsetSharedPtr>& rsid_to_rowset,
+ vectorized::Block* output_block) {
+ // do partial update related works
+ // 1. read columns by read plan
+ // 2. generate new block
+ // 3. write a new segment and modify rowset meta
+ // 4. mark current keys deleted
+ CHECK(output_block);
+ auto full_mutable_columns = output_block->mutate_columns();
+ auto old_block = rowset_schema->create_missing_columns_block();
+ auto missing_cids = rowset_schema->get_missing_cids();
+ auto update_block = rowset_schema->create_update_columns_block();
+ auto update_cids = rowset_schema->get_update_cids();
+
+ std::map<uint32_t, uint32_t> read_index_old;
+ RETURN_IF_ERROR(read_columns_by_plan(rowset_schema, missing_cids, read_plan_ori, rsid_to_rowset,
+ old_block, &read_index_old));
+
+ std::map<uint32_t, uint32_t> read_index_update;
+ RETURN_IF_ERROR(read_columns_by_plan(rowset_schema, update_cids, read_plan_update,
+ rsid_to_rowset, update_block, &read_index_update));
+
+ // build full block
+ CHECK(read_index_old.size() == read_index_update.size());
+ for (auto i = 0; i < missing_cids.size(); ++i) {
+ for (auto idx = 0; idx < read_index_old.size(); ++idx) {
+ full_mutable_columns[missing_cids[i]]->insert_from(
+ *old_block.get_columns_with_type_and_name()[i].column.get(),
+ read_index_old[idx]);
+ }
+ }
+ for (auto i = 0; i < update_cids.size(); ++i) {
+ for (auto idx = 0; idx < read_index_update.size(); ++idx) {
+ full_mutable_columns[update_cids[i]]->insert_from(
+ *update_block.get_columns_with_type_and_name()[i].column.get(),
+ read_index_update[idx]);
+ }
+ }
+ VLOG_DEBUG << "full block when publish: " << output_block->dump_data();
+ return Status::OK();
+}
+
+// read columns by read plan
+// read_index: ori_pos-> block_idx
+Status Tablet::read_columns_by_plan(TabletSchemaSPtr tablet_schema,
+ const std::vector<uint32_t> cids_to_read,
+ const PartialUpdateReadPlan& read_plan,
+ const std::map<RowsetId, RowsetSharedPtr>& rsid_to_rowset,
+ vectorized::Block& block,
+ std::map<uint32_t, uint32_t>* read_index) {
+ bool has_row_column = tablet_schema->store_row_column();
+ auto mutable_columns = block.mutate_columns();
+ size_t read_idx = 0;
+ for (auto rs_it : read_plan) {
+ for (auto seg_it : rs_it.second) {
+ auto rowset_iter = rsid_to_rowset.find(rs_it.first);
+ CHECK(rowset_iter != rsid_to_rowset.end());
+ std::vector<uint32_t> rids;
+ for (auto id_and_pos : seg_it.second) {
+ rids.emplace_back(id_and_pos.rid);
+ (*read_index)[id_and_pos.pos] = read_idx++;
+ }
+ if (has_row_column) {
+ auto st = fetch_value_through_row_column(rowset_iter->second, seg_it.first, rids,
+ cids_to_read, block);
+ if (!st.ok()) {
+ LOG(WARNING) << "failed to fetch value through row column";
+ return st;
+ }
+ continue;
+ }
+ for (size_t cid = 0; cid < mutable_columns.size(); ++cid) {
+ auto st = fetch_value_by_rowids(rowset_iter->second, seg_it.first, rids,
+ block.get_names()[cid], mutable_columns[cid]);
+ // set read value to output block
+ if (!st.ok()) {
+ LOG(WARNING) << "failed to fetch value";
+ return st;
+ }
+ }
+ }
+ }
+ return Status::OK();
+}
+
+void Tablet::prepare_to_read(const RowLocation& row_location, size_t pos,
+ PartialUpdateReadPlan* read_plan) {
+ auto rs_it = read_plan->find(row_location.rowset_id);
+ if (rs_it == read_plan->end()) {
+ std::map<uint32_t, std::vector<RidAndPos>> segid_to_rid;
+ std::vector<RidAndPos> rid_pos;
+ rid_pos.emplace_back(RidAndPos {row_location.row_id, pos});
+ segid_to_rid.emplace(row_location.segment_id, rid_pos);
+ read_plan->emplace(row_location.rowset_id, segid_to_rid);
+ return;
+ }
+ auto seg_it = rs_it->second.find(row_location.segment_id);
+ if (seg_it == rs_it->second.end()) {
+ std::vector<RidAndPos> rid_pos;
+ rid_pos.emplace_back(RidAndPos {row_location.row_id, pos});
+ rs_it->second.emplace(row_location.segment_id, rid_pos);
+ return;
+ }
+ seg_it->second.emplace_back(RidAndPos {row_location.row_id, pos});
+}
+
Status Tablet::_check_pk_in_pre_segments(
RowsetId rowset_id, const std::vector<segment_v2::SegmentSharedPtr>& pre_segments,
const Slice& key, DeleteBitmapPtr delete_bitmap, RowLocation* loc) {
for (auto it = pre_segments.rbegin(); it != pre_segments.rend(); ++it) {
- auto st = (*it)->lookup_row_key(key, loc);
+ auto st = (*it)->lookup_row_key(key, true, loc);
DCHECK(st.ok() || st.is<NOT_FOUND>() || st.is<ALREADY_EXIST>())
<< "unexpected error status while lookup_row_key:" << st;
if (st.is<NOT_FOUND>()) {
@@ -2655,9 +2960,8 @@ Status Tablet::update_delete_bitmap_without_lock(const RowsetSharedPtr& rowset)
RowsetIdUnorderedSet cur_rowset_ids = all_rs_id(cur_version - 1);
DeleteBitmapPtr delete_bitmap = std::make_shared<DeleteBitmap>(tablet_id());
- RETURN_IF_ERROR(calc_delete_bitmap(rowset->rowset_id(), segments, &cur_rowset_ids,
- delete_bitmap, cur_version - 1, true));
-
+ RETURN_IF_ERROR(
+ calc_delete_bitmap(rowset, segments, nullptr, delete_bitmap, cur_version - 1, true));
for (auto iter = delete_bitmap->delete_bitmap.begin();
iter != delete_bitmap->delete_bitmap.end(); ++iter) {
_tablet_meta->delete_bitmap().merge(
@@ -2667,7 +2971,8 @@ Status Tablet::update_delete_bitmap_without_lock(const RowsetSharedPtr& rowset)
return Status::OK();
}
-Status Tablet::update_delete_bitmap(const RowsetSharedPtr& rowset, const TabletTxnInfo* load_info) {
+Status Tablet::update_delete_bitmap(const RowsetSharedPtr& rowset, const TabletTxnInfo* load_info,
+ RowsetWriter* rowset_writer) {
DeleteBitmapPtr delete_bitmap = load_info->delete_bitmap;
const RowsetIdUnorderedSet& pre_rowset_ids = load_info->rowset_ids;
RowsetIdUnorderedSet cur_rowset_ids;
@@ -2697,8 +3002,8 @@ Status Tablet::update_delete_bitmap(const RowsetSharedPtr& rowset, const TabletT
delete_bitmap->remove({to_del, 0, 0}, {to_del, UINT32_MAX, INT64_MAX});
}
- RETURN_IF_ERROR(calc_delete_bitmap(rowset->rowset_id(), segments, &rowset_ids_to_add,
- delete_bitmap, cur_version - 1, false));
+ RETURN_IF_ERROR(calc_delete_bitmap(rowset, segments, &rowset_ids_to_add, delete_bitmap,
+ cur_version - 1, false, rowset_writer));
// Check the delete_bitmap correctness, now the check is only enabled in DEBUG env.
if (load_info->num_keys != 0) {
diff --git a/be/src/olap/tablet.h b/be/src/olap/tablet.h
index 1fa6d1bc7f..28be7c45a3 100644
--- a/be/src/olap/tablet.h
+++ b/be/src/olap/tablet.h
@@ -309,6 +309,8 @@ public:
Status create_rowset_writer(RowsetWriterContext& context,
std::unique_ptr<RowsetWriter>* rowset_writer);
+ Status create_transient_rowset_writer(RowsetWriterContext& context, const RowsetId& rowset_id,
+ std::unique_ptr<RowsetWriter>* rowset_writer);
Status create_vertical_rowset_writer(RowsetWriterContext& context,
std::unique_ptr<RowsetWriter>* rowset_writer);
@@ -393,9 +395,9 @@ public:
// Lookup the row location of `encoded_key`, the function sets `row_location` on success.
// NOTE: the method only works in unique key model with primary key index, you will got a
// not supported error in other data model.
- Status lookup_row_key(const Slice& encoded_key, const RowsetIdUnorderedSet* rowset_ids,
- RowLocation* row_location, uint32_t version,
- RowsetSharedPtr* rowset = nullptr);
+ Status lookup_row_key(const Slice& encoded_key, bool with_seq_col,
+ const RowsetIdUnorderedSet* rowset_ids, RowLocation* row_location,
+ uint32_t version, RowsetSharedPtr* rowset = nullptr);
// Lookup a row with TupleDescriptor and fill Block
Status lookup_row_data(const Slice& encoded_key, const RowLocation& row_location,
@@ -403,20 +405,44 @@ public:
OlapReaderStatistics& stats, vectorized::Block* block,
bool write_to_cache = false);
+ Status fetch_value_by_rowids(RowsetSharedPtr input_rowset, uint32_t segid,
+ const std::vector<uint32_t>& rowids,
+ const std::string& column_name, vectorized::MutableColumnPtr& dst);
+
+ Status fetch_value_through_row_column(RowsetSharedPtr input_rowset, uint32_t segid,
+ const std::vector<uint32_t>& rowids,
+ const std::vector<uint32_t>& cids,
+ vectorized::Block& block);
+
// calc delete bitmap when flush memtable, use a fake version to calc
// For example, cur max version is 5, and we use version 6 to calc but
// finally this rowset publish version with 8, we should make up data
// for rowset 6-7. Also, if a compaction happens between commit_txn and
// publish_txn, we should remove compaction input rowsets' delete_bitmap
// and build newly generated rowset's delete_bitmap
- Status calc_delete_bitmap(RowsetId rowset_id,
+ Status calc_delete_bitmap(RowsetSharedPtr rowset,
const std::vector<segment_v2::SegmentSharedPtr>& segments,
const RowsetIdUnorderedSet* specified_rowset_ids,
DeleteBitmapPtr delete_bitmap, int64_t version,
- bool check_pre_segments = false);
+ bool check_pre_segments = false,
+ RowsetWriter* rowset_writer = nullptr);
+ Status read_columns_by_plan(TabletSchemaSPtr tablet_schema,
+ const std::vector<uint32_t> cids_to_read,
+ const PartialUpdateReadPlan& read_plan,
+ const std::map<RowsetId, RowsetSharedPtr>& rsid_to_rowset,
+ vectorized::Block& block, std::map<uint32_t, uint32_t>* read_index);
+ void prepare_to_read(const RowLocation& row_location, size_t pos,
+ PartialUpdateReadPlan* read_plan);
+ Status generate_new_block_for_partial_update(
+ TabletSchemaSPtr rowset_schema, const PartialUpdateReadPlan& read_plan_ori,
+ const PartialUpdateReadPlan& read_plan_update,
+ const std::map<RowsetId, RowsetSharedPtr>& rsid_to_rowset,
+ vectorized::Block* output_block);
Status update_delete_bitmap_without_lock(const RowsetSharedPtr& rowset);
- Status update_delete_bitmap(const RowsetSharedPtr& rowset, const TabletTxnInfo* load_info);
+
+ Status update_delete_bitmap(const RowsetSharedPtr& rowset, const TabletTxnInfo* load_info,
+ RowsetWriter* rowset_writer = nullptr);
void calc_compaction_output_rowset_delete_bitmap(
const std::vector<RowsetSharedPtr>& input_rowsets,
const RowIdConversion& rowid_conversion, uint64_t start_version, uint64_t end_version,
@@ -429,6 +455,7 @@ public:
const std::map<RowsetSharedPtr, std::list<std::pair<RowLocation, RowLocation>>>&
location_map);
RowsetIdUnorderedSet all_rs_id(int64_t max_version) const;
+ void sort_block(vectorized::Block& in_block, vectorized::Block& output_block);
bool check_all_rowset_segment();
diff --git a/be/src/olap/tablet_schema.cpp b/be/src/olap/tablet_schema.cpp
index 174a1e13fb..7c288f30ff 100644
--- a/be/src/olap/tablet_schema.cpp
+++ b/be/src/olap/tablet_schema.cpp
@@ -642,6 +642,9 @@ void TabletSchema::init_from_pb(const TabletSchemaPB& schema) {
_indexes.clear();
_field_name_to_index.clear();
_field_id_to_index.clear();
+ _partial_update_input_columns.clear();
+ _missing_cids.clear();
+ _update_cids.clear();
for (auto& column_pb : schema.column()) {
TabletColumn column;
column.init_from_pb(column_pb);
@@ -683,6 +686,23 @@ void TabletSchema::init_from_pb(const TabletSchemaPB& schema) {
_sort_col_num = schema.sort_col_num();
_compression_type = schema.compression_type();
_schema_version = schema.schema_version();
+ _is_partial_update = schema.is_partial_update();
+ for (auto& col_name : schema.partial_update_input_columns()) {
+ _partial_update_input_columns.emplace(col_name);
+ }
+ if (_is_partial_update) {
+ for (auto i = 0; i < _cols.size(); ++i) {
+ if (_partial_update_input_columns.count(_cols[i].name()) == 0) {
+ _missing_cids.emplace_back(i);
+ auto tablet_column = column(i);
+ if (!tablet_column.has_default_value()) {
+ _allow_key_not_exist_in_partial_update = false;
+ }
+ } else {
+ _update_cids.emplace_back(i);
+ }
+ }
+ }
}
void TabletSchema::copy_from(const TabletSchema& tablet_schema) {
@@ -817,6 +837,10 @@ void TabletSchema::to_schema_pb(TabletSchemaPB* tablet_schema_pb) const {
tablet_schema_pb->set_compression_type(_compression_type);
tablet_schema_pb->set_is_dynamic_schema(_is_dynamic_schema);
tablet_schema_pb->set_version_col_idx(_version_col_idx);
+ tablet_schema_pb->set_is_partial_update(_is_partial_update);
+ for (auto& col : _partial_update_input_columns) {
+ *tablet_schema_pb->add_partial_update_input_columns() = col;
+ }
}
size_t TabletSchema::row_size() const {
@@ -981,6 +1005,54 @@ vectorized::Block TabletSchema::create_block(bool ignore_dropped_col) const {
return block;
}
+vectorized::Block TabletSchema::create_missing_columns_block() {
+ vectorized::Block block;
+ for (const auto& cid : _missing_cids) {
+ auto col = _cols[cid];
+ auto data_type = vectorized::DataTypeFactory::instance().create_data_type(col);
+ block.insert({data_type->create_column(), data_type, col.name()});
+ }
+ return block;
+}
+
+vectorized::Block TabletSchema::create_update_columns_block() {
+ vectorized::Block block;
+ for (const auto& cid : _update_cids) {
+ auto col = _cols[cid];
+ auto data_type = vectorized::DataTypeFactory::instance().create_data_type(col);
+ block.insert({data_type->create_column(), data_type, col.name()});
+ }
+ return block;
+}
+
+void TabletSchema::set_partial_update_info(bool is_partial_update,
+ const std::set<string>& partial_update_input_columns) {
+ _is_partial_update = is_partial_update;
+ _partial_update_input_columns = partial_update_input_columns;
+ for (auto i = 0; i < _cols.size(); ++i) {
+ if (_partial_update_input_columns.count(_cols[i].name()) == 0) {
+ _missing_cids.emplace_back(i);
+ auto tablet_column = column(i);
+ if (!tablet_column.has_default_value()) {
+ _allow_key_not_exist_in_partial_update = false;
+ }
+ } else {
+ _update_cids.emplace_back(i);
+ }
+ }
+}
+
+bool TabletSchema::is_column_missing(size_t cid) const {
+ DCHECK(cid < _cols.size());
+ if (!_is_partial_update) {
+ return false;
+ }
+ if (_partial_update_input_columns.count(_cols[cid].name()) == 0) {
+ return true;
+ }
+ return false;
+}
+
bool operator==(const TabletColumn& a, const TabletColumn& b) {
if (a._unique_id != b._unique_id) return false;
if (a._col_name != b._col_name) return false;
diff --git a/be/src/olap/tablet_schema.h b/be/src/olap/tablet_schema.h
index a77bc03ebd..0249a87ef2 100644
--- a/be/src/olap/tablet_schema.h
+++ b/be/src/olap/tablet_schema.h
@@ -282,6 +282,18 @@ public:
str += "]";
return str;
}
+ vectorized::Block create_missing_columns_block();
+ vectorized::Block create_update_columns_block();
+ void set_partial_update_info(bool is_partial_update,
+ const std::set<string>& partial_update_input_columns);
+ bool is_partial_update() const { return _is_partial_update; }
+ size_t partial_input_column_size() const { return _partial_update_input_columns.size(); }
+ bool is_column_missing(size_t cid) const;
+ bool allow_key_not_exist_in_partial_update() const {
+ return _allow_key_not_exist_in_partial_update;
+ }
+ std::vector<uint32_t> get_missing_cids() { return _missing_cids; }
+ std::vector<uint32_t> get_update_cids() { return _update_cids; }
private:
friend bool operator==(const TabletSchema& a, const TabletSchema& b);
@@ -316,6 +328,13 @@ private:
bool _disable_auto_compaction = false;
int64_t _mem_size = 0;
bool _store_row_column = false;
+
+ bool _is_partial_update;
+ std::set<std::string> _partial_update_input_columns;
+ std::vector<uint32_t> _missing_cids;
+ std::vector<uint32_t> _update_cids;
+ // if key not exist in old rowset, use default value or null
+ bool _allow_key_not_exist_in_partial_update = true;
};
bool operator==(const TabletSchema& a, const TabletSchema& b);
diff --git a/be/src/olap/txn_manager.cpp b/be/src/olap/txn_manager.cpp
index d43bf44444..5df068630b 100644
--- a/be/src/olap/txn_manager.cpp
+++ b/be/src/olap/txn_manager.cpp
@@ -35,6 +35,8 @@
#include "olap/delta_writer.h"
#include "olap/rowset/rowset_meta.h"
#include "olap/rowset/rowset_meta_manager.h"
+#include "olap/schema_change.h"
+#include "olap/segment_loader.h"
#include "olap/storage_engine.h"
#include "olap/tablet_manager.h"
#include "olap/tablet_meta.h"
@@ -327,7 +329,21 @@ Status TxnManager::publish_txn(OlapMeta* meta, TPartitionId partition_id,
if (tablet == nullptr) {
return Status::OK();
}
- RETURN_IF_ERROR(tablet->update_delete_bitmap(rowset_ptr, &load_info));
+ std::unique_ptr<RowsetWriter> rowset_writer;
+ _create_transient_rowset_writer(tablet, rowset_ptr->rowset_id(),
+ rowset_ptr->num_segments(), &rowset_writer);
+
+ RETURN_IF_ERROR(tablet->update_delete_bitmap(rowset_ptr, &load_info,
+ rowset_writer.get()));
+ if (rowset_ptr->tablet_schema()->is_partial_update()) {
+ // build rowset writer and merge transient rowset
+ RETURN_NOT_OK(rowset_writer->flush());
+ RowsetSharedPtr transient_rowset = rowset_writer->build();
+ rowset_ptr->merge_rowset_meta(transient_rowset->rowset_meta());
+
+ // erase segment cache cause we will add a segment to rowset
+ SegmentLoader::instance()->erase_segment(rowset_ptr->rowset_id());
+ }
std::shared_lock rlock(tablet->get_header_lock());
tablet->save_meta();
}
@@ -366,6 +382,25 @@ Status TxnManager::publish_txn(OlapMeta* meta, TPartitionId partition_id,
return Status::OK();
}
+// create a rowset writer with rowset_id and seg_id
+// after writer, merge this transient rowset with original rowset
+Status TxnManager::_create_transient_rowset_writer(std::shared_ptr<Tablet> tablet,
+ const RowsetId& rowset_id,
+ int32_t num_segments_ori,
+ std::unique_ptr<RowsetWriter>* rowset_writer) {
+ RowsetWriterContext context;
+ context.rowset_state = PREPARED;
+ context.segments_overlap = OVERLAPPING;
+ context.tablet_schema = tablet->tablet_schema();
+ context.newest_write_timestamp = UnixSeconds();
+ context.tablet_id = tablet->table_id();
+ context.tablet = tablet;
+ context.is_direct_write = true;
+ RETURN_NOT_OK(tablet->create_transient_rowset_writer(context, rowset_id, rowset_writer));
+ (*rowset_writer)->set_segment_start_id(num_segments_ori);
+ return Status::OK();
+}
+
// txn could be rollbacked if it does not have related rowset
// if the txn has related rowset then could not rollback it, because it
// may be committed in another thread and our current thread meets errors when writing to data file
diff --git a/be/src/olap/txn_manager.h b/be/src/olap/txn_manager.h
index ad986fbe9e..40925bc61d 100644
--- a/be/src/olap/txn_manager.h
+++ b/be/src/olap/txn_manager.h
@@ -37,9 +37,13 @@
#include "common/status.h"
#include "olap/olap_common.h"
#include "olap/rowset/rowset.h"
+#include "olap/rowset/rowset_meta.h"
+#include "olap/rowset/segment_v2/segment.h"
+#include "olap/rowset/segment_v2/segment_writer.h"
#include "olap/tablet.h"
#include "olap/tablet_meta.h"
#include "util/time.h"
+#include "vec/core/block.h"
namespace doris {
class DeltaWriter;
@@ -207,6 +211,10 @@ private:
void _insert_txn_partition_map_unlocked(int64_t transaction_id, int64_t partition_id);
void _clear_txn_partition_map_unlocked(int64_t transaction_id, int64_t partition_id);
+ Status _create_transient_rowset_writer(std::shared_ptr<Tablet> tablet,
+ const RowsetId& rowset_id, int32_t num_segments_ori,
+ std::unique_ptr<RowsetWriter>* rowset_writer);
+
private:
const int32_t _txn_map_shard_size;
diff --git a/be/src/service/point_query_executor.cpp b/be/src/service/point_query_executor.cpp
index 3c77fcd2f3..21d6ac06ac 100644
--- a/be/src/service/point_query_executor.cpp
+++ b/be/src/service/point_query_executor.cpp
@@ -255,7 +255,7 @@ Status PointQueryExecutor::_lookup_row_key() {
}
// Get rowlocation and rowset, ctx._rowset_ptr will acquire wrap this ptr
auto rowset_ptr = std::make_unique<RowsetSharedPtr>();
- st = (_tablet->lookup_row_key(_row_read_ctxs[i]._primary_key, nullptr, &location,
+ st = (_tablet->lookup_row_key(_row_read_ctxs[i]._primary_key, true, nullptr, &location,
INT32_MAX /*rethink?*/, rowset_ptr.get()));
if (st.is_not_found()) {
continue;
diff --git a/be/src/vec/jsonb/serialize.cpp b/be/src/vec/jsonb/serialize.cpp
index 6be0a7f965..69bc603b2f 100644
--- a/be/src/vec/jsonb/serialize.cpp
+++ b/be/src/vec/jsonb/serialize.cpp
@@ -80,6 +80,34 @@ void JsonbSerializeUtil::jsonb_to_block(const TupleDescriptor& desc, const char*
JsonbValue* slot_value = doc->find(slot->col_unique_id());
MutableColumnPtr dst_column = dst.get_by_position(j).column->assume_mutable();
if (!slot_value || slot_value->isNull()) {
+ // null or not exist
+ dst_column->insert_default();
+ continue;
+ }
+ dst.get_data_type(j)->get_serde()->read_one_cell_from_jsonb(*dst_column, slot_value);
+ }
+}
+
+void JsonbSerializeUtil::jsonb_to_block(TabletSchemaSPtr schema,
+ const std::vector<uint32_t>& col_ids,
+ const ColumnString& jsonb_column, Block& dst) {
+ for (int i = 0; i < jsonb_column.size(); ++i) {
+ StringRef jsonb_data = jsonb_column.get_data_at(i);
+ jsonb_to_block(schema, col_ids, jsonb_data.data, jsonb_data.size, dst);
+ }
+}
+
+void JsonbSerializeUtil::jsonb_to_block(TabletSchemaSPtr schema,
+ const std::vector<uint32_t>& col_ids, const char* data,
+ size_t size, Block& dst) {
+ auto pdoc = JsonbDocument::createDocument(data, size);
+ JsonbDocument& doc = *pdoc;
+ for (int j = 0; j < col_ids.size(); ++j) {
+ auto column = schema->column(col_ids[j]);
+ JsonbValue* slot_value = doc->find(column.unique_id());
+ MutableColumnPtr dst_column = dst.get_by_position(j).column->assume_mutable();
+ if (!slot_value || slot_value->isNull()) {
+ // null or not exist
dst_column->insert_default();
continue;
}
diff --git a/be/src/vec/jsonb/serialize.h b/be/src/vec/jsonb/serialize.h
index 0d9d13927d..4aa9eef0f8 100644
--- a/be/src/vec/jsonb/serialize.h
+++ b/be/src/vec/jsonb/serialize.h
@@ -18,6 +18,9 @@
#pragma once
#include <stddef.h>
+#include "olap/tablet_schema.h"
+#include "runtime/descriptors.h"
+#include "vec/columns/column_string.h"
#include "vec/core/block.h"
namespace doris {
@@ -41,5 +44,13 @@ public:
// single row
static void jsonb_to_block(const TupleDescriptor& desc, const char* data, size_t size,
Block& dst);
+
+ static void jsonb_to_block(TabletSchemaSPtr schema, const std::vector<uint32_t>& col_ids,
+ const ColumnString& jsonb_column, Block& dst);
+
+ static void jsonb_to_block(TabletSchemaSPtr schema, const std::vector<uint32_t>& col_ids,
+ const char* data, size_t size, Block& dst);
+
+ static PrimitiveType get_primity_type(FieldType type);
};
} // namespace doris::vectorized
\ No newline at end of file
diff --git a/be/src/vec/olap/olap_data_convertor.cpp b/be/src/vec/olap/olap_data_convertor.cpp
index a9eaae7e75..ab1cd1ed6e 100644
--- a/be/src/vec/olap/olap_data_convertor.cpp
+++ b/be/src/vec/olap/olap_data_convertor.cpp
@@ -178,6 +178,16 @@ void OlapBlockDataConvertor::set_source_content(const vectorized::Block* block,
}
}
+void OlapBlockDataConvertor::set_source_content_with_specifid_columns(
+ const vectorized::Block* block, size_t row_pos, size_t num_rows,
+ std::vector<uint32_t> cids) {
+ assert(block && num_rows > 0 && row_pos + num_rows <= block->rows() &&
+ block->columns() <= _convertors.size());
+ for (auto i : cids) {
+ _convertors[i]->set_source_column(block->get_by_position(i), row_pos, num_rows);
+ }
+}
+
void OlapBlockDataConvertor::clear_source_content() {
for (auto& convertor : _convertors) {
convertor->clear_source_column();
diff --git a/be/src/vec/olap/olap_data_convertor.h b/be/src/vec/olap/olap_data_convertor.h
index 67847542b5..d9d95cb427 100644
--- a/be/src/vec/olap/olap_data_convertor.h
+++ b/be/src/vec/olap/olap_data_convertor.h
@@ -73,6 +73,8 @@ public:
OlapBlockDataConvertor(const TabletSchema* tablet_schema);
OlapBlockDataConvertor(const TabletSchema* tablet_schema, const std::vector<uint32_t>& col_ids);
void set_source_content(const vectorized::Block* block, size_t row_pos, size_t num_rows);
+ void set_source_content_with_specifid_columns(const vectorized::Block* block, size_t row_pos,
+ size_t num_rows, std::vector<uint32_t> cids);
void clear_source_content();
std::pair<Status, IOlapColumnDataAccessor*> convert_column_data(size_t cid);
void add_column_data_convertor(const TabletColumn& column);
diff --git a/be/test/io/cache/remote_file_cache_test.cpp b/be/test/io/cache/remote_file_cache_test.cpp
index f1c1e6d14c..5c1b932cc4 100644
--- a/be/test/io/cache/remote_file_cache_test.cpp
+++ b/be/test/io/cache/remote_file_cache_test.cpp
@@ -116,7 +116,8 @@ protected:
EXPECT_TRUE(st.ok());
DataDir data_dir(kSegmentDir);
data_dir.init();
- SegmentWriter writer(file_writer.get(), 0, build_schema, &data_dir, INT32_MAX, opts);
+ SegmentWriter writer(file_writer.get(), 0, build_schema, nullptr, &data_dir, INT32_MAX,
+ opts, nullptr);
st = writer.init();
EXPECT_TRUE(st.ok());
diff --git a/be/test/olap/tablet_test.cpp b/be/test/olap/tablet_test.cpp
index bc1a38ca54..7f02295209 100644
--- a/be/test/olap/tablet_test.cpp
+++ b/be/test/olap/tablet_test.cpp
@@ -418,23 +418,23 @@ TEST_F(TestTablet, rowset_tree_update) {
RowLocation loc;
// Key not in range.
- ASSERT_TRUE(tablet->lookup_row_key("99", &rowset_ids, &loc, 7).is<NOT_FOUND>());
+ ASSERT_TRUE(tablet->lookup_row_key("99", true, &rowset_ids, &loc, 7).is<NOT_FOUND>());
// Version too low.
- ASSERT_TRUE(tablet->lookup_row_key("101", &rowset_ids, &loc, 3).is<NOT_FOUND>());
+ ASSERT_TRUE(tablet->lookup_row_key("101", true, &rowset_ids, &loc, 3).is<NOT_FOUND>());
// Hit a segment, but since we don't have real data, return an internal error when loading the
// segment.
- LOG(INFO) << tablet->lookup_row_key("101", &rowset_ids, &loc, 7).to_string();
- ASSERT_TRUE(tablet->lookup_row_key("101", &rowset_ids, &loc, 7).is<IO_ERROR>());
+ LOG(INFO) << tablet->lookup_row_key("101", true, &rowset_ids, &loc, 7).to_string();
+ ASSERT_TRUE(tablet->lookup_row_key("101", true, &rowset_ids, &loc, 7).is<IO_ERROR>());
// Key not in range.
- ASSERT_TRUE(tablet->lookup_row_key("201", &rowset_ids, &loc, 7).is<NOT_FOUND>());
- ASSERT_TRUE(tablet->lookup_row_key("300", &rowset_ids, &loc, 7).is<IO_ERROR>());
+ ASSERT_TRUE(tablet->lookup_row_key("201", true, &rowset_ids, &loc, 7).is<NOT_FOUND>());
+ ASSERT_TRUE(tablet->lookup_row_key("300", true, &rowset_ids, &loc, 7).is<IO_ERROR>());
// Key not in range.
- ASSERT_TRUE(tablet->lookup_row_key("499", &rowset_ids, &loc, 7).is<NOT_FOUND>());
+ ASSERT_TRUE(tablet->lookup_row_key("499", true, &rowset_ids, &loc, 7).is<NOT_FOUND>());
// Version too low.
- ASSERT_TRUE(tablet->lookup_row_key("500", &rowset_ids, &loc, 7).is<NOT_FOUND>());
+ ASSERT_TRUE(tablet->lookup_row_key("500", true, &rowset_ids, &loc, 7).is<NOT_FOUND>());
// Hit a segment, but since we don't have real data, return an internal error when loading the
// segment.
- ASSERT_TRUE(tablet->lookup_row_key("500", &rowset_ids, &loc, 8).is<IO_ERROR>());
+ ASSERT_TRUE(tablet->lookup_row_key("500", true, &rowset_ids, &loc, 8).is<IO_ERROR>());
}
} // namespace doris
diff --git a/be/test/olap/test_data/header_without_inc_rs.txt b/be/test/olap/test_data/header_without_inc_rs.txt
index e96b93e8cf..5475211f7f 100644
--- a/be/test/olap/test_data/header_without_inc_rs.txt
+++ b/be/test/olap/test_data/header_without_inc_rs.txt
@@ -59,7 +59,8 @@
"disable_auto_compaction": false,
"version_col_idx": -1,
"store_row_column": false,
- "is_dynamic_schema": false
+ "is_dynamic_schema": false,
+ "is_partial_update": false
},
"rs_metas": [
{
diff --git a/fe/fe-core/src/main/java/org/apache/doris/load/Load.java b/fe/fe-core/src/main/java/org/apache/doris/load/Load.java
index 2b15a53dee..ecc7178418 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/load/Load.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/load/Load.java
@@ -542,7 +542,8 @@ public class Load {
*/
public static void initColumns(Table tbl, List<ImportColumnDesc> columnExprs,
Map<String, Pair<String, List<String>>> columnToHadoopFunction) throws UserException {
- initColumns(tbl, columnExprs, columnToHadoopFunction, null, null, null, null, null, null, null, false, false);
+ initColumns(tbl, columnExprs, columnToHadoopFunction, null, null, null, null, null, null, null, false, false,
+ false);
}
/*
@@ -552,11 +553,12 @@ public class Load {
public static void initColumns(Table tbl, LoadTaskInfo.ImportColumnDescs columnDescs,
Map<String, Pair<String, List<String>>> columnToHadoopFunction, Map<String, Expr> exprsByName,
Analyzer analyzer, TupleDescriptor srcTupleDesc, Map<String, SlotDescriptor> slotDescByName,
- List<Integer> srcSlotIds, TFileFormatType formatType, List<String> hiddenColumns, boolean useVectorizedLoad)
+ List<Integer> srcSlotIds, TFileFormatType formatType, List<String> hiddenColumns, boolean useVectorizedLoad,
+ boolean isPartialUpdate)
throws UserException {
rewriteColumns(columnDescs);
initColumns(tbl, columnDescs.descs, columnToHadoopFunction, exprsByName, analyzer, srcTupleDesc, slotDescByName,
- srcSlotIds, formatType, hiddenColumns, useVectorizedLoad, true);
+ srcSlotIds, formatType, hiddenColumns, useVectorizedLoad, true, isPartialUpdate);
}
/*
@@ -571,7 +573,7 @@ public class Load {
Map<String, Pair<String, List<String>>> columnToHadoopFunction, Map<String, Expr> exprsByName,
Analyzer analyzer, TupleDescriptor srcTupleDesc, Map<String, SlotDescriptor> slotDescByName,
List<Integer> srcSlotIds, TFileFormatType formatType, List<String> hiddenColumns, boolean useVectorizedLoad,
- boolean needInitSlotAndAnalyzeExprs) throws UserException {
+ boolean needInitSlotAndAnalyzeExprs, boolean isPartialUpdate) throws UserException {
// We make a copy of the columnExprs so that our subsequent changes
// to the columnExprs will not affect the original columnExprs.
// skip the mapping columns not exist in schema
@@ -635,9 +637,10 @@ public class Load {
if (columnExprMap.containsKey(columnName)) {
continue;
}
- if (column.getDefaultValue() != null || column.isAllowNull()) {
+ if (column.getDefaultValue() != null || column.isAllowNull() || isPartialUpdate) {
continue;
}
+ //continue;
throw new DdlException("Column has no default value. column: " + columnName);
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/load/routineload/RoutineLoadJob.java b/fe/fe-core/src/main/java/org/apache/doris/load/routineload/RoutineLoadJob.java
index 56b4807681..6937c9ad01 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/load/routineload/RoutineLoadJob.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/load/routineload/RoutineLoadJob.java
@@ -587,6 +587,11 @@ public abstract class RoutineLoadJob extends AbstractTxnStateChangeCallback impl
return null;
}
+ @Override
+ public boolean isPartialUpdate() {
+ return false;
+ }
+
@Override
public ImportColumnDescs getColumnExprDescs() {
if (columnDescs == null) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/planner/FileLoadScanNode.java b/fe/fe-core/src/main/java/org/apache/doris/planner/FileLoadScanNode.java
index c3639f34e7..07d1ff445f 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/planner/FileLoadScanNode.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/planner/FileLoadScanNode.java
@@ -109,9 +109,9 @@ public class FileLoadScanNode extends FileScanNode {
// Only for stream load/routine load job.
public void setLoadInfo(TUniqueId loadId, long txnId, Table targetTable, BrokerDesc brokerDesc,
BrokerFileGroup fileGroup, TBrokerFileStatus fileStatus, boolean strictMode,
- TFileType fileType, List<String> hiddenColumns) {
+ TFileType fileType, List<String> hiddenColumns, boolean isPartialUpdate) {
FileGroupInfo fileGroupInfo = new FileGroupInfo(loadId, txnId, targetTable, brokerDesc,
- fileGroup, fileStatus, strictMode, fileType, hiddenColumns);
+ fileGroup, fileStatus, strictMode, fileType, hiddenColumns, isPartialUpdate);
fileGroupInfos.add(fileGroupInfo);
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/planner/OlapTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/planner/OlapTableSink.java
index 92b5dd7780..0ebd3fb7e5 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/planner/OlapTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/planner/OlapTableSink.java
@@ -77,6 +77,7 @@ import org.apache.logging.log4j.Logger;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
@@ -90,6 +91,9 @@ public class OlapTableSink extends DataSink {
private TupleDescriptor tupleDescriptor;
// specified partition ids.
private List<Long> partitionIds;
+ // partial update input columns
+ private boolean isPartialUpdate = false;
+ private HashSet<String> partialUpdateInputColumns;
// set after init called
private TDataSink tDataSink;
@@ -140,6 +144,11 @@ public class OlapTableSink extends DataSink {
}
}
+ public void setPartialUpdateInputColumns(boolean isPartialUpdate, HashSet<String> columns) {
+ this.isPartialUpdate = isPartialUpdate;
+ this.partialUpdateInputColumns = columns;
+ }
+
public void updateLoadId(TUniqueId newLoadId) {
tDataSink.getOlapTableSink().setLoadId(newLoadId);
}
@@ -231,6 +240,12 @@ public class OlapTableSink extends DataSink {
indexSchema.setIndexesDesc(indexDesc);
schemaParam.addToIndexes(indexSchema);
}
+ schemaParam.setIsPartialUpdate(isPartialUpdate);
+ if (isPartialUpdate) {
+ for (String s : partialUpdateInputColumns) {
+ schemaParam.addToPartialUpdateInputColumns(s);
+ }
+ }
return schemaParam;
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/planner/StreamLoadPlanner.java b/fe/fe-core/src/main/java/org/apache/doris/planner/StreamLoadPlanner.java
index 552e99b83f..a461a60e99 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/planner/StreamLoadPlanner.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/planner/StreamLoadPlanner.java
@@ -70,6 +70,7 @@ import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -137,8 +138,37 @@ public class StreamLoadPlanner {
// construct tuple descriptor, used for scanNode
scanTupleDesc = descTable.createTupleDescriptor("ScanTuple");
boolean negative = taskInfo.getNegative();
+ // get partial update related info
+ boolean isPartialUpdate = taskInfo.isPartialUpdate();
+ if (isPartialUpdate && !destTable.getEnableUniqueKeyMergeOnWrite()) {
+ throw new UserException("Only unique key merge on write support partial update");
+ }
+ HashSet<String> partialUpdateInputColumns = new HashSet<>();
+ if (isPartialUpdate) {
+ for (Column col : destTable.getFullSchema()) {
+ boolean existInExpr = false;
+ for (ImportColumnDesc importColumnDesc : taskInfo.getColumnExprDescs().descs) {
+ if (importColumnDesc.getColumnName() != null
+ && importColumnDesc.getColumnName().equals(col.getName())) {
+ if (!col.isVisible()) {
+ throw new UserException("Partial update should not include invisible column: "
+ + col.getName());
+ }
+ partialUpdateInputColumns.add(col.getName());
+ existInExpr = true;
+ break;
+ }
+ }
+ if (col.isKey() && !existInExpr) {
+ throw new UserException("Partial update should include all key columns, missing: " + col.getName());
+ }
+ }
+ }
// here we should be full schema to fill the descriptor table
for (Column col : destTable.getFullSchema()) {
+ if (isPartialUpdate && !partialUpdateInputColumns.contains(col.getName())) {
+ continue;
+ }
SlotDescriptor slotDesc = descTable.addSlotDescriptor(tupleDesc);
slotDesc.setIsMaterialized(true);
slotDesc.setColumn(col);
@@ -201,7 +231,8 @@ public class StreamLoadPlanner {
}
// The load id will pass to csv reader to find the stream load context from new load stream manager
fileScanNode.setLoadInfo(loadId, taskInfo.getTxnId(), destTable, BrokerDesc.createForStreamLoad(),
- fileGroup, fileStatus, taskInfo.isStrictMode(), taskInfo.getFileType(), taskInfo.getHiddenColumns());
+ fileGroup, fileStatus, taskInfo.isStrictMode(), taskInfo.getFileType(), taskInfo.getHiddenColumns(),
+ taskInfo.isPartialUpdate());
scanNode = fileScanNode;
scanNode.init(analyzer);
@@ -222,6 +253,7 @@ public class StreamLoadPlanner {
Config.enable_single_replica_load);
olapTableSink.init(loadId, taskInfo.getTxnId(), db.getId(), timeout,
taskInfo.getSendBatchParallelism(), taskInfo.isLoadToSingleTablet());
+ olapTableSink.setPartialUpdateInputColumns(isPartialUpdate, partialUpdateInputColumns);
olapTableSink.complete();
// for stream load, we only need one fragment, ScanNode -> DataSink.
diff --git a/fe/fe-core/src/main/java/org/apache/doris/planner/external/FileGroupInfo.java b/fe/fe-core/src/main/java/org/apache/doris/planner/external/FileGroupInfo.java
index 39292c5e4c..9cff4be56b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/planner/external/FileGroupInfo.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/planner/external/FileGroupInfo.java
@@ -85,6 +85,7 @@ public class FileGroupInfo {
// used for stream load, FILE_LOCAL or FILE_STREAM
private TFileType fileType;
private List<String> hiddenColumns = null;
+ private boolean isPartialUpdate = false;
// for broker load
public FileGroupInfo(long loadJobId, long txnId, Table targetTable, BrokerDesc brokerDesc,
@@ -106,7 +107,7 @@ public class FileGroupInfo {
// for stream load
public FileGroupInfo(TUniqueId loadId, long txnId, Table targetTable, BrokerDesc brokerDesc,
BrokerFileGroup fileGroup, TBrokerFileStatus fileStatus, boolean strictMode,
- TFileType fileType, List<String> hiddenColumns) {
+ TFileType fileType, List<String> hiddenColumns, boolean isPartialUpdate) {
this.jobType = JobType.STREAM_LOAD;
this.loadId = loadId;
this.txnId = txnId;
@@ -119,6 +120,7 @@ public class FileGroupInfo {
this.strictMode = strictMode;
this.fileType = fileType;
this.hiddenColumns = hiddenColumns;
+ this.isPartialUpdate = isPartialUpdate;
}
public Table getTargetTable() {
@@ -159,6 +161,10 @@ public class FileGroupInfo {
return hiddenColumns;
}
+ public boolean isPartialUpdate() {
+ return isPartialUpdate;
+ }
+
public void getFileStatusAndCalcInstance(FederationBackendPolicy backendPolicy) throws UserException {
if (filesAdded == 0) {
throw new UserException("No source file in this table(" + targetTable.getName() + ").");
diff --git a/fe/fe-core/src/main/java/org/apache/doris/planner/external/LoadScanProvider.java b/fe/fe-core/src/main/java/org/apache/doris/planner/external/LoadScanProvider.java
index cac20c78fa..ea079b644e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/planner/external/LoadScanProvider.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/planner/external/LoadScanProvider.java
@@ -207,7 +207,7 @@ public class LoadScanProvider implements FileScanProviderIf {
Load.initColumns(fileGroupInfo.getTargetTable(), columnDescs, context.fileGroup.getColumnToHadoopFunction(),
context.exprMap, analyzer, context.srcTupleDescriptor, context.srcSlotDescByName, srcSlotIds,
formatType(context.fileGroup.getFileFormat(), ""), fileGroupInfo.getHiddenColumns(),
- VectorizedUtil.isVectorized());
+ VectorizedUtil.isVectorized(), fileGroupInfo.isPartialUpdate());
int columnCountFromPath = 0;
if (context.fileGroup.getColumnNamesFromPath() != null) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/task/LoadTaskInfo.java b/fe/fe-core/src/main/java/org/apache/doris/task/LoadTaskInfo.java
index 6e3133fbde..951921fa04 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/task/LoadTaskInfo.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/task/LoadTaskInfo.java
@@ -97,6 +97,8 @@ public interface LoadTaskInfo {
List<String> getHiddenColumns();
+ boolean isPartialUpdate();
+
default boolean getTrimDoubleQuotes() {
return false;
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/task/StreamLoadTask.java b/fe/fe-core/src/main/java/org/apache/doris/task/StreamLoadTask.java
index 2d28cc3b5c..d494d4cda5 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/task/StreamLoadTask.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/task/StreamLoadTask.java
@@ -83,6 +83,8 @@ public class StreamLoadTask implements LoadTaskInfo {
private String headerType = "";
private List<String> hiddenColumns;
private boolean trimDoubleQuotes = false;
+ private boolean isPartialUpdate = false;
+
private int skipLines = 0;
private boolean enableProfile = false;
@@ -268,6 +270,11 @@ public class StreamLoadTask implements LoadTaskInfo {
return enableProfile;
}
+ @Override
+ public boolean isPartialUpdate() {
+ return isPartialUpdate;
+ }
+
public static StreamLoadTask fromTStreamLoadPutRequest(TStreamLoadPutRequest request) throws UserException {
StreamLoadTask streamLoadTask = new StreamLoadTask(request.getLoadId(), request.getTxnId(),
request.getFileType(), request.getFormatType(),
@@ -376,6 +383,9 @@ public class StreamLoadTask implements LoadTaskInfo {
if (request.isSetEnableProfile()) {
enableProfile = request.isEnableProfile();
}
+ if (request.isSetPartialUpdate()) {
+ isPartialUpdate = request.isPartialUpdate();
+ }
}
// used for stream load
diff --git a/gensrc/proto/descriptors.proto b/gensrc/proto/descriptors.proto
index 9660a6707d..ff8c946124 100644
--- a/gensrc/proto/descriptors.proto
+++ b/gensrc/proto/descriptors.proto
@@ -63,5 +63,7 @@ message POlapTableSchemaParam {
repeated PSlotDescriptor slot_descs = 4;
required PTupleDescriptor tuple_desc = 5;
repeated POlapTableIndexSchema indexes = 6;
+ optional bool partial_update = 7;
+ repeated string partial_update_input_columns = 8;
};
diff --git a/gensrc/proto/olap_file.proto b/gensrc/proto/olap_file.proto
index 4d9c05b369..18196fe9e2 100644
--- a/gensrc/proto/olap_file.proto
+++ b/gensrc/proto/olap_file.proto
@@ -231,6 +231,8 @@ message TabletSchemaPB {
optional int32 version_col_idx = 17 [default = -1];
optional bool store_row_column = 18 [default=false]; // store tuplerow oriented column
optional bool is_dynamic_schema = 19 [default=false];
+ optional bool is_partial_update = 20 [default=false];
+ repeated string partial_update_input_columns = 21;
}
enum TabletStatePB {
diff --git a/gensrc/thrift/Descriptors.thrift b/gensrc/thrift/Descriptors.thrift
index 9a5043972c..8a7f60ba78 100644
--- a/gensrc/thrift/Descriptors.thrift
+++ b/gensrc/thrift/Descriptors.thrift
@@ -205,6 +205,8 @@ struct TOlapTableSchemaParam {
5: required TTupleDescriptor tuple_desc
6: required list<TOlapTableIndexSchema> indexes
7: optional bool is_dynamic_schema
+ 8: optional bool is_partial_update
+ 9: optional list<string> partial_update_input_columns
}
struct TOlapTableIndex {
diff --git a/gensrc/thrift/FrontendService.thrift b/gensrc/thrift/FrontendService.thrift
index 54ec33c360..a88edd7680 100644
--- a/gensrc/thrift/FrontendService.thrift
+++ b/gensrc/thrift/FrontendService.thrift
@@ -576,6 +576,7 @@ struct TStreamLoadPutRequest {
42: optional bool trim_double_quotes // trim double quotes for csv
43: optional i32 skip_lines // csv skip line num, only used when csv header_type is not set.
44: optional bool enable_profile
+ 45: optional bool partial_update
}
struct TStreamLoadPutResult {
diff --git a/regression-test/data/unique_with_mow_p0/partial_update/10000.csv b/regression-test/data/unique_with_mow_p0/partial_update/10000.csv
new file mode 100644
index 0000000000..484e6ab563
--- /dev/null
+++ b/regression-test/data/unique_with_mow_p0/partial_update/10000.csv
@@ -0,0 +1,10001 @@
+0,0,1
+1,1,2
+2,2,3
+3,3,4
+4,4,5
+5,5,6
+6,6,7
+7,7,8
+8,8,9
+9,9,10
+10,10,11
+11,11,12
+12,12,13
+13,13,14
+14,14,15
+15,15,16
+16,16,17
+17,17,18
+18,18,19
+19,19,20
+20,20,21
+21,21,22
+22,22,23
+23,23,24
+24,24,25
+25,25,26
+26,26,27
+27,27,28
+28,28,29
+29,29,30
+30,30,31
+31,31,32
+32,32,33
+33,33,34
+34,34,35
+35,35,36
+36,36,37
+37,37,38
+38,38,39
+39,39,40
+40,40,41
+41,41,42
+42,42,43
+43,43,44
+44,44,45
+45,45,46
+46,46,47
+47,47,48
+48,48,49
+49,49,50
+50,50,51
+51,51,52
+52,52,53
+53,53,54
+54,54,55
+55,55,56
+56,56,57
+57,57,58
+58,58,59
+59,59,60
+60,60,61
+61,61,62
+62,62,63
+63,63,64
+64,64,65
+65,65,66
+66,66,67
+67,67,68
+68,68,69
+69,69,70
+70,70,71
+71,71,72
+72,72,73
+73,73,74
+74,74,75
+75,75,76
+76,76,77
+77,77,78
+78,78,79
+79,79,80
+80,80,81
+81,81,82
+82,82,83
+83,83,84
+84,84,85
+85,85,86
+86,86,87
+87,87,88
+88,88,89
+89,89,90
+90,90,91
+91,91,92
+92,92,93
+93,93,94
+94,94,95
+95,95,96
+96,96,97
+97,97,98
+98,98,99
+99,99,100
+100,100,101
+101,101,102
+102,102,103
+103,103,104
+104,104,105
+105,105,106
+106,106,107
+107,107,108
+108,108,109
+109,109,110
+110,110,111
+111,111,112
+112,112,113
+113,113,114
+114,114,115
+115,115,116
+116,116,117
+117,117,118
+118,118,119
+119,119,120
+120,120,121
+121,121,122
+122,122,123
+123,123,124
+124,124,125
+125,125,126
+126,126,127
+127,127,128
+128,128,129
+129,129,130
+130,130,131
+131,131,132
+132,132,133
+133,133,134
+134,134,135
+135,135,136
+136,136,137
+137,137,138
+138,138,139
+139,139,140
+140,140,141
+141,141,142
+142,142,143
+143,143,144
+144,144,145
+145,145,146
+146,146,147
+147,147,148
+148,148,149
+149,149,150
+150,150,151
+151,151,152
+152,152,153
+153,153,154
+154,154,155
+155,155,156
+156,156,157
+157,157,158
+158,158,159
+159,159,160
+160,160,161
+161,161,162
+162,162,163
+163,163,164
+164,164,165
+165,165,166
+166,166,167
+167,167,168
+168,168,169
+169,169,170
+170,170,171
+171,171,172
+172,172,173
+173,173,174
+174,174,175
+175,175,176
+176,176,177
+177,177,178
+178,178,179
+179,179,180
+180,180,181
+181,181,182
+182,182,183
+183,183,184
+184,184,185
+185,185,186
+186,186,187
+187,187,188
+188,188,189
+189,189,190
+190,190,191
+191,191,192
+192,192,193
+193,193,194
+194,194,195
+195,195,196
+196,196,197
+197,197,198
+198,198,199
+199,199,200
+200,200,201
+201,201,202
+202,202,203
+203,203,204
+204,204,205
+205,205,206
+206,206,207
+207,207,208
+208,208,209
+209,209,210
+210,210,211
+211,211,212
+212,212,213
+213,213,214
+214,214,215
+215,215,216
+216,216,217
+217,217,218
+218,218,219
+219,219,220
+220,220,221
+221,221,222
+222,222,223
+223,223,224
+224,224,225
+225,225,226
+226,226,227
+227,227,228
+228,228,229
+229,229,230
+230,230,231
+231,231,232
+232,232,233
+233,233,234
+234,234,235
+235,235,236
+236,236,237
+237,237,238
+238,238,239
+239,239,240
+240,240,241
+241,241,242
+242,242,243
+243,243,244
+244,244,245
+245,245,246
+246,246,247
+247,247,248
+248,248,249
+249,249,250
+250,250,251
+251,251,252
+252,252,253
+253,253,254
+254,254,255
+255,255,256
+256,256,257
+257,257,258
+258,258,259
+259,259,260
+260,260,261
+261,261,262
+262,262,263
+263,263,264
+264,264,265
+265,265,266
+266,266,267
+267,267,268
+268,268,269
+269,269,270
+270,270,271
+271,271,272
+272,272,273
+273,273,274
+274,274,275
+275,275,276
+276,276,277
+277,277,278
+278,278,279
+279,279,280
+280,280,281
+281,281,282
+282,282,283
+283,283,284
+284,284,285
+285,285,286
+286,286,287
+287,287,288
+288,288,289
+289,289,290
+290,290,291
+291,291,292
+292,292,293
+293,293,294
+294,294,295
+295,295,296
+296,296,297
+297,297,298
+298,298,299
+299,299,300
+300,300,301
+301,301,302
+302,302,303
+303,303,304
+304,304,305
+305,305,306
+306,306,307
+307,307,308
+308,308,309
+309,309,310
+310,310,311
+311,311,312
+312,312,313
+313,313,314
+314,314,315
+315,315,316
+316,316,317
+317,317,318
+318,318,319
+319,319,320
+320,320,321
+321,321,322
+322,322,323
+323,323,324
+324,324,325
+325,325,326
+326,326,327
+327,327,328
+328,328,329
+329,329,330
+330,330,331
+331,331,332
+332,332,333
+333,333,334
+334,334,335
+335,335,336
+336,336,337
+337,337,338
+338,338,339
+339,339,340
+340,340,341
+341,341,342
+342,342,343
+343,343,344
+344,344,345
+345,345,346
+346,346,347
+347,347,348
+348,348,349
+349,349,350
+350,350,351
+351,351,352
+352,352,353
+353,353,354
+354,354,355
+355,355,356
+356,356,357
+357,357,358
+358,358,359
+359,359,360
+360,360,361
+361,361,362
+362,362,363
+363,363,364
+364,364,365
+365,365,366
+366,366,367
+367,367,368
+368,368,369
+369,369,370
+370,370,371
+371,371,372
+372,372,373
+373,373,374
+374,374,375
+375,375,376
+376,376,377
+377,377,378
+378,378,379
+379,379,380
+380,380,381
+381,381,382
+382,382,383
+383,383,384
+384,384,385
+385,385,386
+386,386,387
+387,387,388
+388,388,389
+389,389,390
+390,390,391
+391,391,392
+392,392,393
+393,393,394
+394,394,395
+395,395,396
+396,396,397
+397,397,398
+398,398,399
+399,399,400
+400,400,401
+401,401,402
+402,402,403
+403,403,404
+404,404,405
+405,405,406
+406,406,407
+407,407,408
+408,408,409
+409,409,410
+410,410,411
+411,411,412
+412,412,413
+413,413,414
+414,414,415
+415,415,416
+416,416,417
+417,417,418
+418,418,419
+419,419,420
+420,420,421
+421,421,422
+422,422,423
+423,423,424
+424,424,425
+425,425,426
+426,426,427
+427,427,428
+428,428,429
+429,429,430
+430,430,431
+431,431,432
+432,432,433
+433,433,434
+434,434,435
+435,435,436
+436,436,437
+437,437,438
+438,438,439
+439,439,440
+440,440,441
+441,441,442
+442,442,443
+443,443,444
+444,444,445
+445,445,446
+446,446,447
+447,447,448
+448,448,449
+449,449,450
+450,450,451
+451,451,452
+452,452,453
+453,453,454
+454,454,455
+455,455,456
+456,456,457
+457,457,458
+458,458,459
+459,459,460
+460,460,461
+461,461,462
+462,462,463
+463,463,464
+464,464,465
+465,465,466
+466,466,467
+467,467,468
+468,468,469
+469,469,470
+470,470,471
+471,471,472
+472,472,473
+473,473,474
+474,474,475
+475,475,476
+476,476,477
+477,477,478
+478,478,479
+479,479,480
+480,480,481
+481,481,482
+482,482,483
+483,483,484
+484,484,485
+485,485,486
+486,486,487
+487,487,488
+488,488,489
+489,489,490
+490,490,491
+491,491,492
+492,492,493
+493,493,494
+494,494,495
+495,495,496
+496,496,497
+497,497,498
+498,498,499
+499,499,500
+500,500,501
+501,501,502
+502,502,503
+503,503,504
+504,504,505
+505,505,506
+506,506,507
+507,507,508
+508,508,509
+509,509,510
+510,510,511
+511,511,512
+512,512,513
+513,513,514
+514,514,515
+515,515,516
+516,516,517
+517,517,518
+518,518,519
+519,519,520
+520,520,521
+521,521,522
+522,522,523
+523,523,524
+524,524,525
+525,525,526
+526,526,527
+527,527,528
+528,528,529
+529,529,530
+530,530,531
+531,531,532
+532,532,533
+533,533,534
+534,534,535
+535,535,536
+536,536,537
+537,537,538
+538,538,539
+539,539,540
+540,540,541
+541,541,542
+542,542,543
+543,543,544
+544,544,545
+545,545,546
+546,546,547
+547,547,548
+548,548,549
+549,549,550
+550,550,551
+551,551,552
+552,552,553
+553,553,554
+554,554,555
+555,555,556
+556,556,557
+557,557,558
+558,558,559
+559,559,560
+560,560,561
+561,561,562
+562,562,563
+563,563,564
+564,564,565
+565,565,566
+566,566,567
+567,567,568
+568,568,569
+569,569,570
+570,570,571
+571,571,572
+572,572,573
+573,573,574
+574,574,575
+575,575,576
+576,576,577
+577,577,578
+578,578,579
+579,579,580
+580,580,581
+581,581,582
+582,582,583
+583,583,584
+584,584,585
+585,585,586
+586,586,587
+587,587,588
+588,588,589
+589,589,590
+590,590,591
+591,591,592
+592,592,593
+593,593,594
+594,594,595
+595,595,596
+596,596,597
+597,597,598
+598,598,599
+599,599,600
+600,600,601
+601,601,602
+602,602,603
+603,603,604
+604,604,605
+605,605,606
+606,606,607
+607,607,608
+608,608,609
+609,609,610
+610,610,611
+611,611,612
+612,612,613
+613,613,614
+614,614,615
+615,615,616
+616,616,617
+617,617,618
+618,618,619
+619,619,620
+620,620,621
+621,621,622
+622,622,623
+623,623,624
+624,624,625
+625,625,626
+626,626,627
+627,627,628
+628,628,629
+629,629,630
+630,630,631
+631,631,632
+632,632,633
+633,633,634
+634,634,635
+635,635,636
+636,636,637
+637,637,638
+638,638,639
+639,639,640
+640,640,641
+641,641,642
+642,642,643
+643,643,644
+644,644,645
+645,645,646
+646,646,647
+647,647,648
+648,648,649
+649,649,650
+650,650,651
+651,651,652
+652,652,653
+653,653,654
+654,654,655
+655,655,656
+656,656,657
+657,657,658
+658,658,659
+659,659,660
+660,660,661
+661,661,662
+662,662,663
+663,663,664
+664,664,665
+665,665,666
+666,666,667
+667,667,668
+668,668,669
+669,669,670
+670,670,671
+671,671,672
+672,672,673
+673,673,674
+674,674,675
+675,675,676
+676,676,677
+677,677,678
+678,678,679
+679,679,680
+680,680,681
+681,681,682
+682,682,683
+683,683,684
+684,684,685
+685,685,686
+686,686,687
+687,687,688
+688,688,689
+689,689,690
+690,690,691
+691,691,692
+692,692,693
+693,693,694
+694,694,695
+695,695,696
+696,696,697
+697,697,698
+698,698,699
+699,699,700
+700,700,701
+701,701,702
+702,702,703
+703,703,704
+704,704,705
+705,705,706
+706,706,707
+707,707,708
+708,708,709
+709,709,710
+710,710,711
+711,711,712
+712,712,713
+713,713,714
+714,714,715
+715,715,716
+716,716,717
+717,717,718
+718,718,719
+719,719,720
+720,720,721
+721,721,722
+722,722,723
+723,723,724
+724,724,725
+725,725,726
+726,726,727
+727,727,728
+728,728,729
+729,729,730
+730,730,731
+731,731,732
+732,732,733
+733,733,734
+734,734,735
+735,735,736
+736,736,737
+737,737,738
+738,738,739
+739,739,740
+740,740,741
+741,741,742
+742,742,743
+743,743,744
+744,744,745
+745,745,746
+746,746,747
+747,747,748
+748,748,749
+749,749,750
+750,750,751
+751,751,752
+752,752,753
+753,753,754
+754,754,755
+755,755,756
+756,756,757
+757,757,758
+758,758,759
+759,759,760
+760,760,761
+761,761,762
+762,762,763
+763,763,764
+764,764,765
+765,765,766
+766,766,767
+767,767,768
+768,768,769
+769,769,770
+770,770,771
+771,771,772
+772,772,773
+773,773,774
+774,774,775
+775,775,776
+776,776,777
+777,777,778
+778,778,779
+779,779,780
+780,780,781
+781,781,782
+782,782,783
+783,783,784
+784,784,785
+785,785,786
+786,786,787
+787,787,788
+788,788,789
+789,789,790
+790,790,791
+791,791,792
+792,792,793
+793,793,794
+794,794,795
+795,795,796
+796,796,797
+797,797,798
+798,798,799
+799,799,800
+800,800,801
+801,801,802
+802,802,803
+803,803,804
+804,804,805
+805,805,806
+806,806,807
+807,807,808
+808,808,809
+809,809,810
+810,810,811
+811,811,812
+812,812,813
+813,813,814
+814,814,815
+815,815,816
+816,816,817
+817,817,818
+818,818,819
+819,819,820
+820,820,821
+821,821,822
+822,822,823
+823,823,824
+824,824,825
+825,825,826
+826,826,827
+827,827,828
+828,828,829
+829,829,830
+830,830,831
+831,831,832
+832,832,833
+833,833,834
+834,834,835
+835,835,836
+836,836,837
+837,837,838
+838,838,839
+839,839,840
+840,840,841
+841,841,842
+842,842,843
+843,843,844
+844,844,845
+845,845,846
+846,846,847
+847,847,848
+848,848,849
+849,849,850
+850,850,851
+851,851,852
+852,852,853
+853,853,854
+854,854,855
+855,855,856
+856,856,857
+857,857,858
+858,858,859
+859,859,860
+860,860,861
+861,861,862
+862,862,863
+863,863,864
+864,864,865
+865,865,866
+866,866,867
+867,867,868
+868,868,869
+869,869,870
+870,870,871
+871,871,872
+872,872,873
+873,873,874
+874,874,875
+875,875,876
+876,876,877
+877,877,878
+878,878,879
+879,879,880
+880,880,881
+881,881,882
+882,882,883
+883,883,884
+884,884,885
+885,885,886
+886,886,887
+887,887,888
+888,888,889
+889,889,890
+890,890,891
+891,891,892
+892,892,893
+893,893,894
+894,894,895
+895,895,896
+896,896,897
+897,897,898
+898,898,899
+899,899,900
+900,900,901
+901,901,902
+902,902,903
+903,903,904
+904,904,905
+905,905,906
+906,906,907
+907,907,908
+908,908,909
+909,909,910
+910,910,911
+911,911,912
+912,912,913
+913,913,914
+914,914,915
+915,915,916
+916,916,917
+917,917,918
+918,918,919
+919,919,920
+920,920,921
+921,921,922
+922,922,923
+923,923,924
+924,924,925
+925,925,926
+926,926,927
+927,927,928
+928,928,929
+929,929,930
+930,930,931
+931,931,932
+932,932,933
+933,933,934
+934,934,935
+935,935,936
+936,936,937
+937,937,938
+938,938,939
+939,939,940
+940,940,941
+941,941,942
+942,942,943
+943,943,944
+944,944,945
+945,945,946
+946,946,947
+947,947,948
+948,948,949
+949,949,950
+950,950,951
+951,951,952
+952,952,953
+953,953,954
+954,954,955
+955,955,956
+956,956,957
+957,957,958
+958,958,959
+959,959,960
+960,960,961
+961,961,962
+962,962,963
+963,963,964
+964,964,965
+965,965,966
+966,966,967
+967,967,968
+968,968,969
+969,969,970
+970,970,971
+971,971,972
+972,972,973
+973,973,974
+974,974,975
+975,975,976
+976,976,977
+977,977,978
+978,978,979
+979,979,980
+980,980,981
+981,981,982
+982,982,983
+983,983,984
+984,984,985
+985,985,986
+986,986,987
+987,987,988
+988,988,989
+989,989,990
+990,990,991
+991,991,992
+992,992,993
+993,993,994
+994,994,995
+995,995,996
+996,996,997
+997,997,998
+998,998,999
+999,999,1000
+1000,1000,1001
+1001,1001,1002
+1002,1002,1003
+1003,1003,1004
+1004,1004,1005
+1005,1005,1006
+1006,1006,1007
+1007,1007,1008
+1008,1008,1009
+1009,1009,1010
+1010,1010,1011
+1011,1011,1012
+1012,1012,1013
+1013,1013,1014
+1014,1014,1015
+1015,1015,1016
+1016,1016,1017
+1017,1017,1018
+1018,1018,1019
+1019,1019,1020
+1020,1020,1021
+1021,1021,1022
+1022,1022,1023
+1023,1023,1024
+1024,1024,1025
+1025,1025,1026
+1026,1026,1027
+1027,1027,1028
+1028,1028,1029
+1029,1029,1030
+1030,1030,1031
+1031,1031,1032
+1032,1032,1033
+1033,1033,1034
+1034,1034,1035
+1035,1035,1036
+1036,1036,1037
+1037,1037,1038
+1038,1038,1039
+1039,1039,1040
+1040,1040,1041
+1041,1041,1042
+1042,1042,1043
+1043,1043,1044
+1044,1044,1045
+1045,1045,1046
+1046,1046,1047
+1047,1047,1048
+1048,1048,1049
+1049,1049,1050
+1050,1050,1051
+1051,1051,1052
+1052,1052,1053
+1053,1053,1054
+1054,1054,1055
+1055,1055,1056
+1056,1056,1057
+1057,1057,1058
+1058,1058,1059
+1059,1059,1060
+1060,1060,1061
+1061,1061,1062
+1062,1062,1063
+1063,1063,1064
+1064,1064,1065
+1065,1065,1066
+1066,1066,1067
+1067,1067,1068
+1068,1068,1069
+1069,1069,1070
+1070,1070,1071
+1071,1071,1072
+1072,1072,1073
+1073,1073,1074
+1074,1074,1075
+1075,1075,1076
+1076,1076,1077
+1077,1077,1078
+1078,1078,1079
+1079,1079,1080
+1080,1080,1081
+1081,1081,1082
+1082,1082,1083
+1083,1083,1084
+1084,1084,1085
+1085,1085,1086
+1086,1086,1087
+1087,1087,1088
+1088,1088,1089
+1089,1089,1090
+1090,1090,1091
+1091,1091,1092
+1092,1092,1093
+1093,1093,1094
+1094,1094,1095
+1095,1095,1096
+1096,1096,1097
+1097,1097,1098
+1098,1098,1099
+1099,1099,1100
+1100,1100,1101
+1101,1101,1102
+1102,1102,1103
+1103,1103,1104
+1104,1104,1105
+1105,1105,1106
+1106,1106,1107
+1107,1107,1108
+1108,1108,1109
+1109,1109,1110
+1110,1110,1111
+1111,1111,1112
+1112,1112,1113
+1113,1113,1114
+1114,1114,1115
+1115,1115,1116
+1116,1116,1117
+1117,1117,1118
+1118,1118,1119
+1119,1119,1120
+1120,1120,1121
+1121,1121,1122
+1122,1122,1123
+1123,1123,1124
+1124,1124,1125
+1125,1125,1126
+1126,1126,1127
+1127,1127,1128
+1128,1128,1129
+1129,1129,1130
+1130,1130,1131
+1131,1131,1132
+1132,1132,1133
+1133,1133,1134
+1134,1134,1135
+1135,1135,1136
+1136,1136,1137
+1137,1137,1138
+1138,1138,1139
+1139,1139,1140
+1140,1140,1141
+1141,1141,1142
+1142,1142,1143
+1143,1143,1144
+1144,1144,1145
+1145,1145,1146
+1146,1146,1147
+1147,1147,1148
+1148,1148,1149
+1149,1149,1150
+1150,1150,1151
+1151,1151,1152
+1152,1152,1153
+1153,1153,1154
+1154,1154,1155
+1155,1155,1156
+1156,1156,1157
+1157,1157,1158
+1158,1158,1159
+1159,1159,1160
+1160,1160,1161
+1161,1161,1162
+1162,1162,1163
+1163,1163,1164
+1164,1164,1165
+1165,1165,1166
+1166,1166,1167
+1167,1167,1168
+1168,1168,1169
+1169,1169,1170
+1170,1170,1171
+1171,1171,1172
+1172,1172,1173
+1173,1173,1174
+1174,1174,1175
+1175,1175,1176
+1176,1176,1177
+1177,1177,1178
+1178,1178,1179
+1179,1179,1180
+1180,1180,1181
+1181,1181,1182
+1182,1182,1183
+1183,1183,1184
+1184,1184,1185
+1185,1185,1186
+1186,1186,1187
+1187,1187,1188
+1188,1188,1189
+1189,1189,1190
+1190,1190,1191
+1191,1191,1192
+1192,1192,1193
+1193,1193,1194
+1194,1194,1195
+1195,1195,1196
+1196,1196,1197
+1197,1197,1198
+1198,1198,1199
+1199,1199,1200
+1200,1200,1201
+1201,1201,1202
+1202,1202,1203
+1203,1203,1204
+1204,1204,1205
+1205,1205,1206
+1206,1206,1207
+1207,1207,1208
+1208,1208,1209
+1209,1209,1210
+1210,1210,1211
+1211,1211,1212
+1212,1212,1213
+1213,1213,1214
+1214,1214,1215
+1215,1215,1216
+1216,1216,1217
+1217,1217,1218
+1218,1218,1219
+1219,1219,1220
+1220,1220,1221
+1221,1221,1222
+1222,1222,1223
+1223,1223,1224
+1224,1224,1225
+1225,1225,1226
+1226,1226,1227
+1227,1227,1228
+1228,1228,1229
+1229,1229,1230
+1230,1230,1231
+1231,1231,1232
+1232,1232,1233
+1233,1233,1234
+1234,1234,1235
+1235,1235,1236
+1236,1236,1237
+1237,1237,1238
+1238,1238,1239
+1239,1239,1240
+1240,1240,1241
+1241,1241,1242
+1242,1242,1243
+1243,1243,1244
+1244,1244,1245
+1245,1245,1246
+1246,1246,1247
+1247,1247,1248
+1248,1248,1249
+1249,1249,1250
+1250,1250,1251
+1251,1251,1252
+1252,1252,1253
+1253,1253,1254
+1254,1254,1255
+1255,1255,1256
+1256,1256,1257
+1257,1257,1258
+1258,1258,1259
+1259,1259,1260
+1260,1260,1261
+1261,1261,1262
+1262,1262,1263
+1263,1263,1264
+1264,1264,1265
+1265,1265,1266
+1266,1266,1267
+1267,1267,1268
+1268,1268,1269
+1269,1269,1270
+1270,1270,1271
+1271,1271,1272
+1272,1272,1273
+1273,1273,1274
+1274,1274,1275
+1275,1275,1276
+1276,1276,1277
+1277,1277,1278
+1278,1278,1279
+1279,1279,1280
+1280,1280,1281
+1281,1281,1282
+1282,1282,1283
+1283,1283,1284
+1284,1284,1285
+1285,1285,1286
+1286,1286,1287
+1287,1287,1288
+1288,1288,1289
+1289,1289,1290
+1290,1290,1291
+1291,1291,1292
+1292,1292,1293
+1293,1293,1294
+1294,1294,1295
+1295,1295,1296
+1296,1296,1297
+1297,1297,1298
+1298,1298,1299
+1299,1299,1300
+1300,1300,1301
+1301,1301,1302
+1302,1302,1303
+1303,1303,1304
+1304,1304,1305
+1305,1305,1306
+1306,1306,1307
+1307,1307,1308
+1308,1308,1309
+1309,1309,1310
+1310,1310,1311
+1311,1311,1312
+1312,1312,1313
+1313,1313,1314
+1314,1314,1315
+1315,1315,1316
+1316,1316,1317
+1317,1317,1318
+1318,1318,1319
+1319,1319,1320
+1320,1320,1321
+1321,1321,1322
+1322,1322,1323
+1323,1323,1324
+1324,1324,1325
+1325,1325,1326
+1326,1326,1327
+1327,1327,1328
+1328,1328,1329
+1329,1329,1330
+1330,1330,1331
+1331,1331,1332
+1332,1332,1333
+1333,1333,1334
+1334,1334,1335
+1335,1335,1336
+1336,1336,1337
+1337,1337,1338
+1338,1338,1339
+1339,1339,1340
+1340,1340,1341
+1341,1341,1342
+1342,1342,1343
+1343,1343,1344
+1344,1344,1345
+1345,1345,1346
+1346,1346,1347
+1347,1347,1348
+1348,1348,1349
+1349,1349,1350
+1350,1350,1351
+1351,1351,1352
+1352,1352,1353
+1353,1353,1354
+1354,1354,1355
+1355,1355,1356
+1356,1356,1357
+1357,1357,1358
+1358,1358,1359
+1359,1359,1360
+1360,1360,1361
+1361,1361,1362
+1362,1362,1363
+1363,1363,1364
+1364,1364,1365
+1365,1365,1366
+1366,1366,1367
+1367,1367,1368
+1368,1368,1369
+1369,1369,1370
+1370,1370,1371
+1371,1371,1372
+1372,1372,1373
+1373,1373,1374
+1374,1374,1375
+1375,1375,1376
+1376,1376,1377
+1377,1377,1378
+1378,1378,1379
+1379,1379,1380
+1380,1380,1381
+1381,1381,1382
+1382,1382,1383
+1383,1383,1384
+1384,1384,1385
+1385,1385,1386
+1386,1386,1387
+1387,1387,1388
+1388,1388,1389
+1389,1389,1390
+1390,1390,1391
+1391,1391,1392
+1392,1392,1393
+1393,1393,1394
+1394,1394,1395
+1395,1395,1396
+1396,1396,1397
+1397,1397,1398
+1398,1398,1399
+1399,1399,1400
+1400,1400,1401
+1401,1401,1402
+1402,1402,1403
+1403,1403,1404
+1404,1404,1405
+1405,1405,1406
+1406,1406,1407
+1407,1407,1408
+1408,1408,1409
+1409,1409,1410
+1410,1410,1411
+1411,1411,1412
+1412,1412,1413
+1413,1413,1414
+1414,1414,1415
+1415,1415,1416
+1416,1416,1417
+1417,1417,1418
+1418,1418,1419
+1419,1419,1420
+1420,1420,1421
+1421,1421,1422
+1422,1422,1423
+1423,1423,1424
+1424,1424,1425
+1425,1425,1426
+1426,1426,1427
+1427,1427,1428
+1428,1428,1429
+1429,1429,1430
+1430,1430,1431
+1431,1431,1432
+1432,1432,1433
+1433,1433,1434
+1434,1434,1435
+1435,1435,1436
+1436,1436,1437
+1437,1437,1438
+1438,1438,1439
+1439,1439,1440
+1440,1440,1441
+1441,1441,1442
+1442,1442,1443
+1443,1443,1444
+1444,1444,1445
+1445,1445,1446
+1446,1446,1447
+1447,1447,1448
+1448,1448,1449
+1449,1449,1450
+1450,1450,1451
+1451,1451,1452
+1452,1452,1453
+1453,1453,1454
+1454,1454,1455
+1455,1455,1456
+1456,1456,1457
+1457,1457,1458
+1458,1458,1459
+1459,1459,1460
+1460,1460,1461
+1461,1461,1462
+1462,1462,1463
+1463,1463,1464
+1464,1464,1465
+1465,1465,1466
+1466,1466,1467
+1467,1467,1468
+1468,1468,1469
+1469,1469,1470
+1470,1470,1471
+1471,1471,1472
+1472,1472,1473
+1473,1473,1474
+1474,1474,1475
+1475,1475,1476
+1476,1476,1477
+1477,1477,1478
+1478,1478,1479
+1479,1479,1480
+1480,1480,1481
+1481,1481,1482
+1482,1482,1483
+1483,1483,1484
+1484,1484,1485
+1485,1485,1486
+1486,1486,1487
+1487,1487,1488
+1488,1488,1489
+1489,1489,1490
+1490,1490,1491
+1491,1491,1492
+1492,1492,1493
+1493,1493,1494
+1494,1494,1495
+1495,1495,1496
+1496,1496,1497
+1497,1497,1498
+1498,1498,1499
+1499,1499,1500
+1500,1500,1501
+1501,1501,1502
+1502,1502,1503
+1503,1503,1504
+1504,1504,1505
+1505,1505,1506
+1506,1506,1507
+1507,1507,1508
+1508,1508,1509
+1509,1509,1510
+1510,1510,1511
+1511,1511,1512
+1512,1512,1513
+1513,1513,1514
+1514,1514,1515
+1515,1515,1516
+1516,1516,1517
+1517,1517,1518
+1518,1518,1519
+1519,1519,1520
+1520,1520,1521
+1521,1521,1522
+1522,1522,1523
+1523,1523,1524
+1524,1524,1525
+1525,1525,1526
+1526,1526,1527
+1527,1527,1528
+1528,1528,1529
+1529,1529,1530
+1530,1530,1531
+1531,1531,1532
+1532,1532,1533
+1533,1533,1534
+1534,1534,1535
+1535,1535,1536
+1536,1536,1537
+1537,1537,1538
+1538,1538,1539
+1539,1539,1540
+1540,1540,1541
+1541,1541,1542
+1542,1542,1543
+1543,1543,1544
+1544,1544,1545
+1545,1545,1546
+1546,1546,1547
+1547,1547,1548
+1548,1548,1549
+1549,1549,1550
+1550,1550,1551
+1551,1551,1552
+1552,1552,1553
+1553,1553,1554
+1554,1554,1555
+1555,1555,1556
+1556,1556,1557
+1557,1557,1558
+1558,1558,1559
+1559,1559,1560
+1560,1560,1561
+1561,1561,1562
+1562,1562,1563
+1563,1563,1564
+1564,1564,1565
+1565,1565,1566
+1566,1566,1567
+1567,1567,1568
+1568,1568,1569
+1569,1569,1570
+1570,1570,1571
+1571,1571,1572
+1572,1572,1573
+1573,1573,1574
+1574,1574,1575
+1575,1575,1576
+1576,1576,1577
+1577,1577,1578
+1578,1578,1579
+1579,1579,1580
+1580,1580,1581
+1581,1581,1582
+1582,1582,1583
+1583,1583,1584
+1584,1584,1585
+1585,1585,1586
+1586,1586,1587
+1587,1587,1588
+1588,1588,1589
+1589,1589,1590
+1590,1590,1591
+1591,1591,1592
+1592,1592,1593
+1593,1593,1594
+1594,1594,1595
+1595,1595,1596
+1596,1596,1597
+1597,1597,1598
+1598,1598,1599
+1599,1599,1600
+1600,1600,1601
+1601,1601,1602
+1602,1602,1603
+1603,1603,1604
+1604,1604,1605
+1605,1605,1606
+1606,1606,1607
+1607,1607,1608
+1608,1608,1609
+1609,1609,1610
+1610,1610,1611
+1611,1611,1612
+1612,1612,1613
+1613,1613,1614
+1614,1614,1615
+1615,1615,1616
+1616,1616,1617
+1617,1617,1618
+1618,1618,1619
+1619,1619,1620
+1620,1620,1621
+1621,1621,1622
+1622,1622,1623
+1623,1623,1624
+1624,1624,1625
+1625,1625,1626
+1626,1626,1627
+1627,1627,1628
+1628,1628,1629
+1629,1629,1630
+1630,1630,1631
+1631,1631,1632
+1632,1632,1633
+1633,1633,1634
+1634,1634,1635
+1635,1635,1636
+1636,1636,1637
+1637,1637,1638
+1638,1638,1639
+1639,1639,1640
+1640,1640,1641
+1641,1641,1642
+1642,1642,1643
+1643,1643,1644
+1644,1644,1645
+1645,1645,1646
+1646,1646,1647
+1647,1647,1648
+1648,1648,1649
+1649,1649,1650
+1650,1650,1651
+1651,1651,1652
+1652,1652,1653
+1653,1653,1654
+1654,1654,1655
+1655,1655,1656
+1656,1656,1657
+1657,1657,1658
+1658,1658,1659
+1659,1659,1660
+1660,1660,1661
+1661,1661,1662
+1662,1662,1663
+1663,1663,1664
+1664,1664,1665
+1665,1665,1666
+1666,1666,1667
+1667,1667,1668
+1668,1668,1669
+1669,1669,1670
+1670,1670,1671
+1671,1671,1672
+1672,1672,1673
+1673,1673,1674
+1674,1674,1675
+1675,1675,1676
+1676,1676,1677
+1677,1677,1678
+1678,1678,1679
+1679,1679,1680
+1680,1680,1681
+1681,1681,1682
+1682,1682,1683
+1683,1683,1684
+1684,1684,1685
+1685,1685,1686
+1686,1686,1687
+1687,1687,1688
+1688,1688,1689
+1689,1689,1690
+1690,1690,1691
+1691,1691,1692
+1692,1692,1693
+1693,1693,1694
+1694,1694,1695
+1695,1695,1696
+1696,1696,1697
+1697,1697,1698
+1698,1698,1699
+1699,1699,1700
+1700,1700,1701
+1701,1701,1702
+1702,1702,1703
+1703,1703,1704
+1704,1704,1705
+1705,1705,1706
+1706,1706,1707
+1707,1707,1708
+1708,1708,1709
+1709,1709,1710
+1710,1710,1711
+1711,1711,1712
+1712,1712,1713
+1713,1713,1714
+1714,1714,1715
+1715,1715,1716
+1716,1716,1717
+1717,1717,1718
+1718,1718,1719
+1719,1719,1720
+1720,1720,1721
+1721,1721,1722
+1722,1722,1723
+1723,1723,1724
+1724,1724,1725
+1725,1725,1726
+1726,1726,1727
+1727,1727,1728
+1728,1728,1729
+1729,1729,1730
+1730,1730,1731
+1731,1731,1732
+1732,1732,1733
+1733,1733,1734
+1734,1734,1735
+1735,1735,1736
+1736,1736,1737
+1737,1737,1738
+1738,1738,1739
+1739,1739,1740
+1740,1740,1741
+1741,1741,1742
+1742,1742,1743
+1743,1743,1744
+1744,1744,1745
+1745,1745,1746
+1746,1746,1747
+1747,1747,1748
+1748,1748,1749
+1749,1749,1750
+1750,1750,1751
+1751,1751,1752
+1752,1752,1753
+1753,1753,1754
+1754,1754,1755
+1755,1755,1756
+1756,1756,1757
+1757,1757,1758
+1758,1758,1759
+1759,1759,1760
+1760,1760,1761
+1761,1761,1762
+1762,1762,1763
+1763,1763,1764
+1764,1764,1765
+1765,1765,1766
+1766,1766,1767
+1767,1767,1768
+1768,1768,1769
+1769,1769,1770
+1770,1770,1771
+1771,1771,1772
+1772,1772,1773
+1773,1773,1774
+1774,1774,1775
+1775,1775,1776
+1776,1776,1777
+1777,1777,1778
+1778,1778,1779
+1779,1779,1780
+1780,1780,1781
+1781,1781,1782
+1782,1782,1783
+1783,1783,1784
+1784,1784,1785
+1785,1785,1786
+1786,1786,1787
+1787,1787,1788
+1788,1788,1789
+1789,1789,1790
+1790,1790,1791
+1791,1791,1792
+1792,1792,1793
+1793,1793,1794
+1794,1794,1795
+1795,1795,1796
+1796,1796,1797
+1797,1797,1798
+1798,1798,1799
+1799,1799,1800
+1800,1800,1801
+1801,1801,1802
+1802,1802,1803
+1803,1803,1804
+1804,1804,1805
+1805,1805,1806
+1806,1806,1807
+1807,1807,1808
+1808,1808,1809
+1809,1809,1810
+1810,1810,1811
+1811,1811,1812
+1812,1812,1813
+1813,1813,1814
+1814,1814,1815
+1815,1815,1816
+1816,1816,1817
+1817,1817,1818
+1818,1818,1819
+1819,1819,1820
+1820,1820,1821
+1821,1821,1822
+1822,1822,1823
+1823,1823,1824
+1824,1824,1825
+1825,1825,1826
+1826,1826,1827
+1827,1827,1828
+1828,1828,1829
+1829,1829,1830
+1830,1830,1831
+1831,1831,1832
+1832,1832,1833
+1833,1833,1834
+1834,1834,1835
+1835,1835,1836
+1836,1836,1837
+1837,1837,1838
+1838,1838,1839
+1839,1839,1840
+1840,1840,1841
+1841,1841,1842
+1842,1842,1843
+1843,1843,1844
+1844,1844,1845
+1845,1845,1846
+1846,1846,1847
+1847,1847,1848
+1848,1848,1849
+1849,1849,1850
+1850,1850,1851
+1851,1851,1852
+1852,1852,1853
+1853,1853,1854
+1854,1854,1855
+1855,1855,1856
+1856,1856,1857
+1857,1857,1858
+1858,1858,1859
+1859,1859,1860
+1860,1860,1861
+1861,1861,1862
+1862,1862,1863
+1863,1863,1864
+1864,1864,1865
+1865,1865,1866
+1866,1866,1867
+1867,1867,1868
+1868,1868,1869
+1869,1869,1870
+1870,1870,1871
+1871,1871,1872
+1872,1872,1873
+1873,1873,1874
+1874,1874,1875
+1875,1875,1876
+1876,1876,1877
+1877,1877,1878
+1878,1878,1879
+1879,1879,1880
+1880,1880,1881
+1881,1881,1882
+1882,1882,1883
+1883,1883,1884
+1884,1884,1885
+1885,1885,1886
+1886,1886,1887
+1887,1887,1888
+1888,1888,1889
+1889,1889,1890
+1890,1890,1891
+1891,1891,1892
+1892,1892,1893
+1893,1893,1894
+1894,1894,1895
+1895,1895,1896
+1896,1896,1897
+1897,1897,1898
+1898,1898,1899
+1899,1899,1900
+1900,1900,1901
+1901,1901,1902
+1902,1902,1903
+1903,1903,1904
+1904,1904,1905
+1905,1905,1906
+1906,1906,1907
+1907,1907,1908
+1908,1908,1909
+1909,1909,1910
+1910,1910,1911
+1911,1911,1912
+1912,1912,1913
+1913,1913,1914
+1914,1914,1915
+1915,1915,1916
+1916,1916,1917
+1917,1917,1918
+1918,1918,1919
+1919,1919,1920
+1920,1920,1921
+1921,1921,1922
+1922,1922,1923
+1923,1923,1924
+1924,1924,1925
+1925,1925,1926
+1926,1926,1927
+1927,1927,1928
+1928,1928,1929
+1929,1929,1930
+1930,1930,1931
+1931,1931,1932
+1932,1932,1933
+1933,1933,1934
+1934,1934,1935
+1935,1935,1936
+1936,1936,1937
+1937,1937,1938
+1938,1938,1939
+1939,1939,1940
+1940,1940,1941
+1941,1941,1942
+1942,1942,1943
+1943,1943,1944
+1944,1944,1945
+1945,1945,1946
+1946,1946,1947
+1947,1947,1948
+1948,1948,1949
+1949,1949,1950
+1950,1950,1951
+1951,1951,1952
+1952,1952,1953
+1953,1953,1954
+1954,1954,1955
+1955,1955,1956
+1956,1956,1957
+1957,1957,1958
+1958,1958,1959
+1959,1959,1960
+1960,1960,1961
+1961,1961,1962
+1962,1962,1963
+1963,1963,1964
+1964,1964,1965
+1965,1965,1966
+1966,1966,1967
+1967,1967,1968
+1968,1968,1969
+1969,1969,1970
+1970,1970,1971
+1971,1971,1972
+1972,1972,1973
+1973,1973,1974
+1974,1974,1975
+1975,1975,1976
+1976,1976,1977
+1977,1977,1978
+1978,1978,1979
+1979,1979,1980
+1980,1980,1981
+1981,1981,1982
+1982,1982,1983
+1983,1983,1984
+1984,1984,1985
+1985,1985,1986
+1986,1986,1987
+1987,1987,1988
+1988,1988,1989
+1989,1989,1990
+1990,1990,1991
+1991,1991,1992
+1992,1992,1993
+1993,1993,1994
+1994,1994,1995
+1995,1995,1996
+1996,1996,1997
+1997,1997,1998
+1998,1998,1999
+1999,1999,2000
+2000,2000,2001
+2001,2001,2002
+2002,2002,2003
+2003,2003,2004
+2004,2004,2005
+2005,2005,2006
+2006,2006,2007
+2007,2007,2008
+2008,2008,2009
+2009,2009,2010
+2010,2010,2011
+2011,2011,2012
+2012,2012,2013
+2013,2013,2014
+2014,2014,2015
+2015,2015,2016
+2016,2016,2017
+2017,2017,2018
+2018,2018,2019
+2019,2019,2020
+2020,2020,2021
+2021,2021,2022
+2022,2022,2023
+2023,2023,2024
+2024,2024,2025
+2025,2025,2026
+2026,2026,2027
+2027,2027,2028
+2028,2028,2029
+2029,2029,2030
+2030,2030,2031
+2031,2031,2032
+2032,2032,2033
+2033,2033,2034
+2034,2034,2035
+2035,2035,2036
+2036,2036,2037
+2037,2037,2038
+2038,2038,2039
+2039,2039,2040
+2040,2040,2041
+2041,2041,2042
+2042,2042,2043
+2043,2043,2044
+2044,2044,2045
+2045,2045,2046
+2046,2046,2047
+2047,2047,2048
+2048,2048,2049
+2049,2049,2050
+2050,2050,2051
+2051,2051,2052
+2052,2052,2053
+2053,2053,2054
+2054,2054,2055
+2055,2055,2056
+2056,2056,2057
+2057,2057,2058
+2058,2058,2059
+2059,2059,2060
+2060,2060,2061
+2061,2061,2062
+2062,2062,2063
+2063,2063,2064
+2064,2064,2065
+2065,2065,2066
+2066,2066,2067
+2067,2067,2068
+2068,2068,2069
+2069,2069,2070
+2070,2070,2071
+2071,2071,2072
+2072,2072,2073
+2073,2073,2074
+2074,2074,2075
+2075,2075,2076
+2076,2076,2077
+2077,2077,2078
+2078,2078,2079
+2079,2079,2080
+2080,2080,2081
+2081,2081,2082
+2082,2082,2083
+2083,2083,2084
+2084,2084,2085
+2085,2085,2086
+2086,2086,2087
+2087,2087,2088
+2088,2088,2089
+2089,2089,2090
+2090,2090,2091
+2091,2091,2092
+2092,2092,2093
+2093,2093,2094
+2094,2094,2095
+2095,2095,2096
+2096,2096,2097
+2097,2097,2098
+2098,2098,2099
+2099,2099,2100
+2100,2100,2101
+2101,2101,2102
+2102,2102,2103
+2103,2103,2104
+2104,2104,2105
+2105,2105,2106
+2106,2106,2107
+2107,2107,2108
+2108,2108,2109
+2109,2109,2110
+2110,2110,2111
+2111,2111,2112
+2112,2112,2113
+2113,2113,2114
+2114,2114,2115
+2115,2115,2116
+2116,2116,2117
+2117,2117,2118
+2118,2118,2119
+2119,2119,2120
+2120,2120,2121
+2121,2121,2122
+2122,2122,2123
+2123,2123,2124
+2124,2124,2125
+2125,2125,2126
+2126,2126,2127
+2127,2127,2128
+2128,2128,2129
+2129,2129,2130
+2130,2130,2131
+2131,2131,2132
+2132,2132,2133
+2133,2133,2134
+2134,2134,2135
+2135,2135,2136
+2136,2136,2137
+2137,2137,2138
+2138,2138,2139
+2139,2139,2140
+2140,2140,2141
+2141,2141,2142
+2142,2142,2143
+2143,2143,2144
+2144,2144,2145
+2145,2145,2146
+2146,2146,2147
+2147,2147,2148
+2148,2148,2149
+2149,2149,2150
+2150,2150,2151
+2151,2151,2152
+2152,2152,2153
+2153,2153,2154
+2154,2154,2155
+2155,2155,2156
+2156,2156,2157
+2157,2157,2158
+2158,2158,2159
+2159,2159,2160
+2160,2160,2161
+2161,2161,2162
+2162,2162,2163
+2163,2163,2164
+2164,2164,2165
+2165,2165,2166
+2166,2166,2167
+2167,2167,2168
+2168,2168,2169
+2169,2169,2170
+2170,2170,2171
+2171,2171,2172
+2172,2172,2173
+2173,2173,2174
+2174,2174,2175
+2175,2175,2176
+2176,2176,2177
+2177,2177,2178
+2178,2178,2179
+2179,2179,2180
+2180,2180,2181
+2181,2181,2182
+2182,2182,2183
+2183,2183,2184
+2184,2184,2185
+2185,2185,2186
+2186,2186,2187
+2187,2187,2188
+2188,2188,2189
+2189,2189,2190
+2190,2190,2191
+2191,2191,2192
+2192,2192,2193
+2193,2193,2194
+2194,2194,2195
+2195,2195,2196
+2196,2196,2197
+2197,2197,2198
+2198,2198,2199
+2199,2199,2200
+2200,2200,2201
+2201,2201,2202
+2202,2202,2203
+2203,2203,2204
+2204,2204,2205
+2205,2205,2206
+2206,2206,2207
+2207,2207,2208
+2208,2208,2209
+2209,2209,2210
+2210,2210,2211
+2211,2211,2212
+2212,2212,2213
+2213,2213,2214
+2214,2214,2215
+2215,2215,2216
+2216,2216,2217
+2217,2217,2218
+2218,2218,2219
+2219,2219,2220
+2220,2220,2221
+2221,2221,2222
+2222,2222,2223
+2223,2223,2224
+2224,2224,2225
+2225,2225,2226
+2226,2226,2227
+2227,2227,2228
+2228,2228,2229
+2229,2229,2230
+2230,2230,2231
+2231,2231,2232
+2232,2232,2233
+2233,2233,2234
+2234,2234,2235
+2235,2235,2236
+2236,2236,2237
+2237,2237,2238
+2238,2238,2239
+2239,2239,2240
+2240,2240,2241
+2241,2241,2242
+2242,2242,2243
+2243,2243,2244
+2244,2244,2245
+2245,2245,2246
+2246,2246,2247
+2247,2247,2248
+2248,2248,2249
+2249,2249,2250
+2250,2250,2251
+2251,2251,2252
+2252,2252,2253
+2253,2253,2254
+2254,2254,2255
+2255,2255,2256
+2256,2256,2257
+2257,2257,2258
+2258,2258,2259
+2259,2259,2260
+2260,2260,2261
+2261,2261,2262
+2262,2262,2263
+2263,2263,2264
+2264,2264,2265
+2265,2265,2266
+2266,2266,2267
+2267,2267,2268
+2268,2268,2269
+2269,2269,2270
+2270,2270,2271
+2271,2271,2272
+2272,2272,2273
+2273,2273,2274
+2274,2274,2275
+2275,2275,2276
+2276,2276,2277
+2277,2277,2278
+2278,2278,2279
+2279,2279,2280
+2280,2280,2281
+2281,2281,2282
+2282,2282,2283
+2283,2283,2284
+2284,2284,2285
+2285,2285,2286
+2286,2286,2287
+2287,2287,2288
+2288,2288,2289
+2289,2289,2290
+2290,2290,2291
+2291,2291,2292
+2292,2292,2293
+2293,2293,2294
+2294,2294,2295
+2295,2295,2296
+2296,2296,2297
+2297,2297,2298
+2298,2298,2299
+2299,2299,2300
+2300,2300,2301
+2301,2301,2302
+2302,2302,2303
+2303,2303,2304
+2304,2304,2305
+2305,2305,2306
+2306,2306,2307
+2307,2307,2308
+2308,2308,2309
+2309,2309,2310
+2310,2310,2311
+2311,2311,2312
+2312,2312,2313
+2313,2313,2314
+2314,2314,2315
+2315,2315,2316
+2316,2316,2317
+2317,2317,2318
+2318,2318,2319
+2319,2319,2320
+2320,2320,2321
+2321,2321,2322
+2322,2322,2323
+2323,2323,2324
+2324,2324,2325
+2325,2325,2326
+2326,2326,2327
+2327,2327,2328
+2328,2328,2329
+2329,2329,2330
+2330,2330,2331
+2331,2331,2332
+2332,2332,2333
+2333,2333,2334
+2334,2334,2335
+2335,2335,2336
+2336,2336,2337
+2337,2337,2338
+2338,2338,2339
+2339,2339,2340
+2340,2340,2341
+2341,2341,2342
+2342,2342,2343
+2343,2343,2344
+2344,2344,2345
+2345,2345,2346
+2346,2346,2347
+2347,2347,2348
+2348,2348,2349
+2349,2349,2350
+2350,2350,2351
+2351,2351,2352
+2352,2352,2353
+2353,2353,2354
+2354,2354,2355
+2355,2355,2356
+2356,2356,2357
+2357,2357,2358
+2358,2358,2359
+2359,2359,2360
+2360,2360,2361
+2361,2361,2362
+2362,2362,2363
+2363,2363,2364
+2364,2364,2365
+2365,2365,2366
+2366,2366,2367
+2367,2367,2368
+2368,2368,2369
+2369,2369,2370
+2370,2370,2371
+2371,2371,2372
+2372,2372,2373
+2373,2373,2374
+2374,2374,2375
+2375,2375,2376
+2376,2376,2377
+2377,2377,2378
+2378,2378,2379
+2379,2379,2380
+2380,2380,2381
+2381,2381,2382
+2382,2382,2383
+2383,2383,2384
+2384,2384,2385
+2385,2385,2386
+2386,2386,2387
+2387,2387,2388
+2388,2388,2389
+2389,2389,2390
+2390,2390,2391
+2391,2391,2392
+2392,2392,2393
+2393,2393,2394
+2394,2394,2395
+2395,2395,2396
+2396,2396,2397
+2397,2397,2398
+2398,2398,2399
+2399,2399,2400
+2400,2400,2401
+2401,2401,2402
+2402,2402,2403
+2403,2403,2404
+2404,2404,2405
+2405,2405,2406
+2406,2406,2407
+2407,2407,2408
+2408,2408,2409
+2409,2409,2410
+2410,2410,2411
+2411,2411,2412
+2412,2412,2413
+2413,2413,2414
+2414,2414,2415
+2415,2415,2416
+2416,2416,2417
+2417,2417,2418
+2418,2418,2419
+2419,2419,2420
+2420,2420,2421
+2421,2421,2422
+2422,2422,2423
+2423,2423,2424
+2424,2424,2425
+2425,2425,2426
+2426,2426,2427
+2427,2427,2428
+2428,2428,2429
+2429,2429,2430
+2430,2430,2431
+2431,2431,2432
+2432,2432,2433
+2433,2433,2434
+2434,2434,2435
+2435,2435,2436
+2436,2436,2437
+2437,2437,2438
+2438,2438,2439
+2439,2439,2440
+2440,2440,2441
+2441,2441,2442
+2442,2442,2443
+2443,2443,2444
+2444,2444,2445
+2445,2445,2446
+2446,2446,2447
+2447,2447,2448
+2448,2448,2449
+2449,2449,2450
+2450,2450,2451
+2451,2451,2452
+2452,2452,2453
+2453,2453,2454
+2454,2454,2455
+2455,2455,2456
+2456,2456,2457
+2457,2457,2458
+2458,2458,2459
+2459,2459,2460
+2460,2460,2461
+2461,2461,2462
+2462,2462,2463
+2463,2463,2464
+2464,2464,2465
+2465,2465,2466
+2466,2466,2467
+2467,2467,2468
+2468,2468,2469
+2469,2469,2470
+2470,2470,2471
+2471,2471,2472
+2472,2472,2473
+2473,2473,2474
+2474,2474,2475
+2475,2475,2476
+2476,2476,2477
+2477,2477,2478
+2478,2478,2479
+2479,2479,2480
+2480,2480,2481
+2481,2481,2482
+2482,2482,2483
+2483,2483,2484
+2484,2484,2485
+2485,2485,2486
+2486,2486,2487
+2487,2487,2488
+2488,2488,2489
+2489,2489,2490
+2490,2490,2491
+2491,2491,2492
+2492,2492,2493
+2493,2493,2494
+2494,2494,2495
+2495,2495,2496
+2496,2496,2497
+2497,2497,2498
+2498,2498,2499
+2499,2499,2500
+2500,2500,2501
+2501,2501,2502
+2502,2502,2503
+2503,2503,2504
+2504,2504,2505
+2505,2505,2506
+2506,2506,2507
+2507,2507,2508
+2508,2508,2509
+2509,2509,2510
+2510,2510,2511
+2511,2511,2512
+2512,2512,2513
+2513,2513,2514
+2514,2514,2515
+2515,2515,2516
+2516,2516,2517
+2517,2517,2518
+2518,2518,2519
+2519,2519,2520
+2520,2520,2521
+2521,2521,2522
+2522,2522,2523
+2523,2523,2524
+2524,2524,2525
+2525,2525,2526
+2526,2526,2527
+2527,2527,2528
+2528,2528,2529
+2529,2529,2530
+2530,2530,2531
+2531,2531,2532
+2532,2532,2533
+2533,2533,2534
+2534,2534,2535
+2535,2535,2536
+2536,2536,2537
+2537,2537,2538
+2538,2538,2539
+2539,2539,2540
+2540,2540,2541
+2541,2541,2542
+2542,2542,2543
+2543,2543,2544
+2544,2544,2545
+2545,2545,2546
+2546,2546,2547
+2547,2547,2548
+2548,2548,2549
+2549,2549,2550
+2550,2550,2551
+2551,2551,2552
+2552,2552,2553
+2553,2553,2554
+2554,2554,2555
+2555,2555,2556
+2556,2556,2557
+2557,2557,2558
+2558,2558,2559
+2559,2559,2560
+2560,2560,2561
+2561,2561,2562
+2562,2562,2563
+2563,2563,2564
+2564,2564,2565
+2565,2565,2566
+2566,2566,2567
+2567,2567,2568
+2568,2568,2569
+2569,2569,2570
+2570,2570,2571
+2571,2571,2572
+2572,2572,2573
+2573,2573,2574
+2574,2574,2575
+2575,2575,2576
+2576,2576,2577
+2577,2577,2578
+2578,2578,2579
+2579,2579,2580
+2580,2580,2581
+2581,2581,2582
+2582,2582,2583
+2583,2583,2584
+2584,2584,2585
+2585,2585,2586
+2586,2586,2587
+2587,2587,2588
+2588,2588,2589
+2589,2589,2590
+2590,2590,2591
+2591,2591,2592
+2592,2592,2593
+2593,2593,2594
+2594,2594,2595
+2595,2595,2596
+2596,2596,2597
+2597,2597,2598
+2598,2598,2599
+2599,2599,2600
+2600,2600,2601
+2601,2601,2602
+2602,2602,2603
+2603,2603,2604
+2604,2604,2605
+2605,2605,2606
+2606,2606,2607
+2607,2607,2608
+2608,2608,2609
+2609,2609,2610
+2610,2610,2611
+2611,2611,2612
+2612,2612,2613
+2613,2613,2614
+2614,2614,2615
+2615,2615,2616
+2616,2616,2617
+2617,2617,2618
+2618,2618,2619
+2619,2619,2620
+2620,2620,2621
+2621,2621,2622
+2622,2622,2623
+2623,2623,2624
+2624,2624,2625
+2625,2625,2626
+2626,2626,2627
+2627,2627,2628
+2628,2628,2629
+2629,2629,2630
+2630,2630,2631
+2631,2631,2632
+2632,2632,2633
+2633,2633,2634
+2634,2634,2635
+2635,2635,2636
+2636,2636,2637
+2637,2637,2638
+2638,2638,2639
+2639,2639,2640
+2640,2640,2641
+2641,2641,2642
+2642,2642,2643
+2643,2643,2644
+2644,2644,2645
+2645,2645,2646
+2646,2646,2647
+2647,2647,2648
+2648,2648,2649
+2649,2649,2650
+2650,2650,2651
+2651,2651,2652
+2652,2652,2653
+2653,2653,2654
+2654,2654,2655
+2655,2655,2656
+2656,2656,2657
+2657,2657,2658
+2658,2658,2659
+2659,2659,2660
+2660,2660,2661
+2661,2661,2662
+2662,2662,2663
+2663,2663,2664
+2664,2664,2665
+2665,2665,2666
+2666,2666,2667
+2667,2667,2668
+2668,2668,2669
+2669,2669,2670
+2670,2670,2671
+2671,2671,2672
+2672,2672,2673
+2673,2673,2674
+2674,2674,2675
+2675,2675,2676
+2676,2676,2677
+2677,2677,2678
+2678,2678,2679
+2679,2679,2680
+2680,2680,2681
+2681,2681,2682
+2682,2682,2683
+2683,2683,2684
+2684,2684,2685
+2685,2685,2686
+2686,2686,2687
+2687,2687,2688
+2688,2688,2689
+2689,2689,2690
+2690,2690,2691
+2691,2691,2692
+2692,2692,2693
+2693,2693,2694
+2694,2694,2695
+2695,2695,2696
+2696,2696,2697
+2697,2697,2698
+2698,2698,2699
+2699,2699,2700
+2700,2700,2701
+2701,2701,2702
+2702,2702,2703
+2703,2703,2704
+2704,2704,2705
+2705,2705,2706
+2706,2706,2707
+2707,2707,2708
+2708,2708,2709
+2709,2709,2710
+2710,2710,2711
+2711,2711,2712
+2712,2712,2713
+2713,2713,2714
+2714,2714,2715
+2715,2715,2716
+2716,2716,2717
+2717,2717,2718
+2718,2718,2719
+2719,2719,2720
+2720,2720,2721
+2721,2721,2722
+2722,2722,2723
+2723,2723,2724
+2724,2724,2725
+2725,2725,2726
+2726,2726,2727
+2727,2727,2728
+2728,2728,2729
+2729,2729,2730
+2730,2730,2731
+2731,2731,2732
+2732,2732,2733
+2733,2733,2734
+2734,2734,2735
+2735,2735,2736
+2736,2736,2737
+2737,2737,2738
+2738,2738,2739
+2739,2739,2740
+2740,2740,2741
+2741,2741,2742
+2742,2742,2743
+2743,2743,2744
+2744,2744,2745
+2745,2745,2746
+2746,2746,2747
+2747,2747,2748
+2748,2748,2749
+2749,2749,2750
+2750,2750,2751
+2751,2751,2752
+2752,2752,2753
+2753,2753,2754
+2754,2754,2755
+2755,2755,2756
+2756,2756,2757
+2757,2757,2758
+2758,2758,2759
+2759,2759,2760
+2760,2760,2761
+2761,2761,2762
+2762,2762,2763
+2763,2763,2764
+2764,2764,2765
+2765,2765,2766
+2766,2766,2767
+2767,2767,2768
+2768,2768,2769
+2769,2769,2770
+2770,2770,2771
+2771,2771,2772
+2772,2772,2773
+2773,2773,2774
+2774,2774,2775
+2775,2775,2776
+2776,2776,2777
+2777,2777,2778
+2778,2778,2779
+2779,2779,2780
+2780,2780,2781
+2781,2781,2782
+2782,2782,2783
+2783,2783,2784
+2784,2784,2785
+2785,2785,2786
+2786,2786,2787
+2787,2787,2788
+2788,2788,2789
+2789,2789,2790
+2790,2790,2791
+2791,2791,2792
+2792,2792,2793
+2793,2793,2794
+2794,2794,2795
+2795,2795,2796
+2796,2796,2797
+2797,2797,2798
+2798,2798,2799
+2799,2799,2800
+2800,2800,2801
+2801,2801,2802
+2802,2802,2803
+2803,2803,2804
+2804,2804,2805
+2805,2805,2806
+2806,2806,2807
+2807,2807,2808
+2808,2808,2809
+2809,2809,2810
+2810,2810,2811
+2811,2811,2812
+2812,2812,2813
+2813,2813,2814
+2814,2814,2815
+2815,2815,2816
+2816,2816,2817
+2817,2817,2818
+2818,2818,2819
+2819,2819,2820
+2820,2820,2821
+2821,2821,2822
+2822,2822,2823
+2823,2823,2824
+2824,2824,2825
+2825,2825,2826
+2826,2826,2827
+2827,2827,2828
+2828,2828,2829
+2829,2829,2830
+2830,2830,2831
+2831,2831,2832
+2832,2832,2833
+2833,2833,2834
+2834,2834,2835
+2835,2835,2836
+2836,2836,2837
+2837,2837,2838
+2838,2838,2839
+2839,2839,2840
+2840,2840,2841
+2841,2841,2842
+2842,2842,2843
+2843,2843,2844
+2844,2844,2845
+2845,2845,2846
+2846,2846,2847
+2847,2847,2848
+2848,2848,2849
+2849,2849,2850
+2850,2850,2851
+2851,2851,2852
+2852,2852,2853
+2853,2853,2854
+2854,2854,2855
+2855,2855,2856
+2856,2856,2857
+2857,2857,2858
+2858,2858,2859
+2859,2859,2860
+2860,2860,2861
+2861,2861,2862
+2862,2862,2863
+2863,2863,2864
+2864,2864,2865
+2865,2865,2866
+2866,2866,2867
+2867,2867,2868
+2868,2868,2869
+2869,2869,2870
+2870,2870,2871
+2871,2871,2872
+2872,2872,2873
+2873,2873,2874
+2874,2874,2875
+2875,2875,2876
+2876,2876,2877
+2877,2877,2878
+2878,2878,2879
+2879,2879,2880
+2880,2880,2881
+2881,2881,2882
+2882,2882,2883
+2883,2883,2884
+2884,2884,2885
+2885,2885,2886
+2886,2886,2887
+2887,2887,2888
+2888,2888,2889
+2889,2889,2890
+2890,2890,2891
+2891,2891,2892
+2892,2892,2893
+2893,2893,2894
+2894,2894,2895
+2895,2895,2896
+2896,2896,2897
+2897,2897,2898
+2898,2898,2899
+2899,2899,2900
+2900,2900,2901
+2901,2901,2902
+2902,2902,2903
+2903,2903,2904
+2904,2904,2905
+2905,2905,2906
+2906,2906,2907
+2907,2907,2908
+2908,2908,2909
+2909,2909,2910
+2910,2910,2911
+2911,2911,2912
+2912,2912,2913
+2913,2913,2914
+2914,2914,2915
+2915,2915,2916
+2916,2916,2917
+2917,2917,2918
+2918,2918,2919
+2919,2919,2920
+2920,2920,2921
+2921,2921,2922
+2922,2922,2923
+2923,2923,2924
+2924,2924,2925
+2925,2925,2926
+2926,2926,2927
+2927,2927,2928
+2928,2928,2929
+2929,2929,2930
+2930,2930,2931
+2931,2931,2932
+2932,2932,2933
+2933,2933,2934
+2934,2934,2935
+2935,2935,2936
+2936,2936,2937
+2937,2937,2938
+2938,2938,2939
+2939,2939,2940
+2940,2940,2941
+2941,2941,2942
+2942,2942,2943
+2943,2943,2944
+2944,2944,2945
+2945,2945,2946
+2946,2946,2947
+2947,2947,2948
+2948,2948,2949
+2949,2949,2950
+2950,2950,2951
+2951,2951,2952
+2952,2952,2953
+2953,2953,2954
+2954,2954,2955
+2955,2955,2956
+2956,2956,2957
+2957,2957,2958
+2958,2958,2959
+2959,2959,2960
+2960,2960,2961
+2961,2961,2962
+2962,2962,2963
+2963,2963,2964
+2964,2964,2965
+2965,2965,2966
+2966,2966,2967
+2967,2967,2968
+2968,2968,2969
+2969,2969,2970
+2970,2970,2971
+2971,2971,2972
+2972,2972,2973
+2973,2973,2974
+2974,2974,2975
+2975,2975,2976
+2976,2976,2977
+2977,2977,2978
+2978,2978,2979
+2979,2979,2980
+2980,2980,2981
+2981,2981,2982
+2982,2982,2983
+2983,2983,2984
+2984,2984,2985
+2985,2985,2986
+2986,2986,2987
+2987,2987,2988
+2988,2988,2989
+2989,2989,2990
+2990,2990,2991
+2991,2991,2992
+2992,2992,2993
+2993,2993,2994
+2994,2994,2995
+2995,2995,2996
+2996,2996,2997
+2997,2997,2998
+2998,2998,2999
+2999,2999,3000
+3000,3000,3001
+3001,3001,3002
+3002,3002,3003
+3003,3003,3004
+3004,3004,3005
+3005,3005,3006
+3006,3006,3007
+3007,3007,3008
+3008,3008,3009
+3009,3009,3010
+3010,3010,3011
+3011,3011,3012
+3012,3012,3013
+3013,3013,3014
+3014,3014,3015
+3015,3015,3016
+3016,3016,3017
+3017,3017,3018
+3018,3018,3019
+3019,3019,3020
+3020,3020,3021
+3021,3021,3022
+3022,3022,3023
+3023,3023,3024
+3024,3024,3025
+3025,3025,3026
+3026,3026,3027
+3027,3027,3028
+3028,3028,3029
+3029,3029,3030
+3030,3030,3031
+3031,3031,3032
+3032,3032,3033
+3033,3033,3034
+3034,3034,3035
+3035,3035,3036
+3036,3036,3037
+3037,3037,3038
+3038,3038,3039
+3039,3039,3040
+3040,3040,3041
+3041,3041,3042
+3042,3042,3043
+3043,3043,3044
+3044,3044,3045
+3045,3045,3046
+3046,3046,3047
+3047,3047,3048
+3048,3048,3049
+3049,3049,3050
+3050,3050,3051
+3051,3051,3052
+3052,3052,3053
+3053,3053,3054
+3054,3054,3055
+3055,3055,3056
+3056,3056,3057
+3057,3057,3058
+3058,3058,3059
+3059,3059,3060
+3060,3060,3061
+3061,3061,3062
+3062,3062,3063
+3063,3063,3064
+3064,3064,3065
+3065,3065,3066
+3066,3066,3067
+3067,3067,3068
+3068,3068,3069
+3069,3069,3070
+3070,3070,3071
+3071,3071,3072
+3072,3072,3073
+3073,3073,3074
+3074,3074,3075
+3075,3075,3076
+3076,3076,3077
+3077,3077,3078
+3078,3078,3079
+3079,3079,3080
+3080,3080,3081
+3081,3081,3082
+3082,3082,3083
+3083,3083,3084
+3084,3084,3085
+3085,3085,3086
+3086,3086,3087
+3087,3087,3088
+3088,3088,3089
+3089,3089,3090
+3090,3090,3091
+3091,3091,3092
+3092,3092,3093
+3093,3093,3094
+3094,3094,3095
+3095,3095,3096
+3096,3096,3097
+3097,3097,3098
+3098,3098,3099
+3099,3099,3100
+3100,3100,3101
+3101,3101,3102
+3102,3102,3103
+3103,3103,3104
+3104,3104,3105
+3105,3105,3106
+3106,3106,3107
+3107,3107,3108
+3108,3108,3109
+3109,3109,3110
+3110,3110,3111
+3111,3111,3112
+3112,3112,3113
+3113,3113,3114
+3114,3114,3115
+3115,3115,3116
+3116,3116,3117
+3117,3117,3118
+3118,3118,3119
+3119,3119,3120
+3120,3120,3121
+3121,3121,3122
+3122,3122,3123
+3123,3123,3124
+3124,3124,3125
+3125,3125,3126
+3126,3126,3127
+3127,3127,3128
+3128,3128,3129
+3129,3129,3130
+3130,3130,3131
+3131,3131,3132
+3132,3132,3133
+3133,3133,3134
+3134,3134,3135
+3135,3135,3136
+3136,3136,3137
+3137,3137,3138
+3138,3138,3139
+3139,3139,3140
+3140,3140,3141
+3141,3141,3142
+3142,3142,3143
+3143,3143,3144
+3144,3144,3145
+3145,3145,3146
+3146,3146,3147
+3147,3147,3148
+3148,3148,3149
+3149,3149,3150
+3150,3150,3151
+3151,3151,3152
+3152,3152,3153
+3153,3153,3154
+3154,3154,3155
+3155,3155,3156
+3156,3156,3157
+3157,3157,3158
+3158,3158,3159
+3159,3159,3160
+3160,3160,3161
+3161,3161,3162
+3162,3162,3163
+3163,3163,3164
+3164,3164,3165
+3165,3165,3166
+3166,3166,3167
+3167,3167,3168
+3168,3168,3169
+3169,3169,3170
+3170,3170,3171
+3171,3171,3172
+3172,3172,3173
+3173,3173,3174
+3174,3174,3175
+3175,3175,3176
+3176,3176,3177
+3177,3177,3178
+3178,3178,3179
+3179,3179,3180
+3180,3180,3181
+3181,3181,3182
+3182,3182,3183
+3183,3183,3184
+3184,3184,3185
+3185,3185,3186
+3186,3186,3187
+3187,3187,3188
+3188,3188,3189
+3189,3189,3190
+3190,3190,3191
+3191,3191,3192
+3192,3192,3193
+3193,3193,3194
+3194,3194,3195
+3195,3195,3196
+3196,3196,3197
+3197,3197,3198
+3198,3198,3199
+3199,3199,3200
+3200,3200,3201
+3201,3201,3202
+3202,3202,3203
+3203,3203,3204
+3204,3204,3205
+3205,3205,3206
+3206,3206,3207
+3207,3207,3208
+3208,3208,3209
+3209,3209,3210
+3210,3210,3211
+3211,3211,3212
+3212,3212,3213
+3213,3213,3214
+3214,3214,3215
+3215,3215,3216
+3216,3216,3217
+3217,3217,3218
+3218,3218,3219
+3219,3219,3220
+3220,3220,3221
+3221,3221,3222
+3222,3222,3223
+3223,3223,3224
+3224,3224,3225
+3225,3225,3226
+3226,3226,3227
+3227,3227,3228
+3228,3228,3229
+3229,3229,3230
+3230,3230,3231
+3231,3231,3232
+3232,3232,3233
+3233,3233,3234
+3234,3234,3235
+3235,3235,3236
+3236,3236,3237
+3237,3237,3238
+3238,3238,3239
+3239,3239,3240
+3240,3240,3241
+3241,3241,3242
+3242,3242,3243
+3243,3243,3244
+3244,3244,3245
+3245,3245,3246
+3246,3246,3247
+3247,3247,3248
+3248,3248,3249
+3249,3249,3250
+3250,3250,3251
+3251,3251,3252
+3252,3252,3253
+3253,3253,3254
+3254,3254,3255
+3255,3255,3256
+3256,3256,3257
+3257,3257,3258
+3258,3258,3259
+3259,3259,3260
+3260,3260,3261
+3261,3261,3262
+3262,3262,3263
+3263,3263,3264
+3264,3264,3265
+3265,3265,3266
+3266,3266,3267
+3267,3267,3268
+3268,3268,3269
+3269,3269,3270
+3270,3270,3271
+3271,3271,3272
+3272,3272,3273
+3273,3273,3274
+3274,3274,3275
+3275,3275,3276
+3276,3276,3277
+3277,3277,3278
+3278,3278,3279
+3279,3279,3280
+3280,3280,3281
+3281,3281,3282
+3282,3282,3283
+3283,3283,3284
+3284,3284,3285
+3285,3285,3286
+3286,3286,3287
+3287,3287,3288
+3288,3288,3289
+3289,3289,3290
+3290,3290,3291
+3291,3291,3292
+3292,3292,3293
+3293,3293,3294
+3294,3294,3295
+3295,3295,3296
+3296,3296,3297
+3297,3297,3298
+3298,3298,3299
+3299,3299,3300
+3300,3300,3301
+3301,3301,3302
+3302,3302,3303
+3303,3303,3304
+3304,3304,3305
+3305,3305,3306
+3306,3306,3307
+3307,3307,3308
+3308,3308,3309
+3309,3309,3310
+3310,3310,3311
+3311,3311,3312
+3312,3312,3313
+3313,3313,3314
+3314,3314,3315
+3315,3315,3316
+3316,3316,3317
+3317,3317,3318
+3318,3318,3319
+3319,3319,3320
+3320,3320,3321
+3321,3321,3322
+3322,3322,3323
+3323,3323,3324
+3324,3324,3325
+3325,3325,3326
+3326,3326,3327
+3327,3327,3328
+3328,3328,3329
+3329,3329,3330
+3330,3330,3331
+3331,3331,3332
+3332,3332,3333
+3333,3333,3334
+3334,3334,3335
+3335,3335,3336
+3336,3336,3337
+3337,3337,3338
+3338,3338,3339
+3339,3339,3340
+3340,3340,3341
+3341,3341,3342
+3342,3342,3343
+3343,3343,3344
+3344,3344,3345
+3345,3345,3346
+3346,3346,3347
+3347,3347,3348
+3348,3348,3349
+3349,3349,3350
+3350,3350,3351
+3351,3351,3352
+3352,3352,3353
+3353,3353,3354
+3354,3354,3355
+3355,3355,3356
+3356,3356,3357
+3357,3357,3358
+3358,3358,3359
+3359,3359,3360
+3360,3360,3361
+3361,3361,3362
+3362,3362,3363
+3363,3363,3364
+3364,3364,3365
+3365,3365,3366
+3366,3366,3367
+3367,3367,3368
+3368,3368,3369
+3369,3369,3370
+3370,3370,3371
+3371,3371,3372
+3372,3372,3373
+3373,3373,3374
+3374,3374,3375
+3375,3375,3376
+3376,3376,3377
+3377,3377,3378
+3378,3378,3379
+3379,3379,3380
+3380,3380,3381
+3381,3381,3382
+3382,3382,3383
+3383,3383,3384
+3384,3384,3385
+3385,3385,3386
+3386,3386,3387
+3387,3387,3388
+3388,3388,3389
+3389,3389,3390
+3390,3390,3391
+3391,3391,3392
+3392,3392,3393
+3393,3393,3394
+3394,3394,3395
+3395,3395,3396
+3396,3396,3397
+3397,3397,3398
+3398,3398,3399
+3399,3399,3400
+3400,3400,3401
+3401,3401,3402
+3402,3402,3403
+3403,3403,3404
+3404,3404,3405
+3405,3405,3406
+3406,3406,3407
+3407,3407,3408
+3408,3408,3409
+3409,3409,3410
+3410,3410,3411
+3411,3411,3412
+3412,3412,3413
+3413,3413,3414
+3414,3414,3415
+3415,3415,3416
+3416,3416,3417
+3417,3417,3418
+3418,3418,3419
+3419,3419,3420
+3420,3420,3421
+3421,3421,3422
+3422,3422,3423
+3423,3423,3424
+3424,3424,3425
+3425,3425,3426
+3426,3426,3427
+3427,3427,3428
+3428,3428,3429
+3429,3429,3430
+3430,3430,3431
+3431,3431,3432
+3432,3432,3433
+3433,3433,3434
+3434,3434,3435
+3435,3435,3436
+3436,3436,3437
+3437,3437,3438
+3438,3438,3439
+3439,3439,3440
+3440,3440,3441
+3441,3441,3442
+3442,3442,3443
+3443,3443,3444
+3444,3444,3445
+3445,3445,3446
+3446,3446,3447
+3447,3447,3448
+3448,3448,3449
+3449,3449,3450
+3450,3450,3451
+3451,3451,3452
+3452,3452,3453
+3453,3453,3454
+3454,3454,3455
+3455,3455,3456
+3456,3456,3457
+3457,3457,3458
+3458,3458,3459
+3459,3459,3460
+3460,3460,3461
+3461,3461,3462
+3462,3462,3463
+3463,3463,3464
+3464,3464,3465
+3465,3465,3466
+3466,3466,3467
+3467,3467,3468
+3468,3468,3469
+3469,3469,3470
+3470,3470,3471
+3471,3471,3472
+3472,3472,3473
+3473,3473,3474
+3474,3474,3475
+3475,3475,3476
+3476,3476,3477
+3477,3477,3478
+3478,3478,3479
+3479,3479,3480
+3480,3480,3481
+3481,3481,3482
+3482,3482,3483
+3483,3483,3484
+3484,3484,3485
+3485,3485,3486
+3486,3486,3487
+3487,3487,3488
+3488,3488,3489
+3489,3489,3490
+3490,3490,3491
+3491,3491,3492
+3492,3492,3493
+3493,3493,3494
+3494,3494,3495
+3495,3495,3496
+3496,3496,3497
+3497,3497,3498
+3498,3498,3499
+3499,3499,3500
+3500,3500,3501
+3501,3501,3502
+3502,3502,3503
+3503,3503,3504
+3504,3504,3505
+3505,3505,3506
+3506,3506,3507
+3507,3507,3508
+3508,3508,3509
+3509,3509,3510
+3510,3510,3511
+3511,3511,3512
+3512,3512,3513
+3513,3513,3514
+3514,3514,3515
+3515,3515,3516
+3516,3516,3517
+3517,3517,3518
+3518,3518,3519
+3519,3519,3520
+3520,3520,3521
+3521,3521,3522
+3522,3522,3523
+3523,3523,3524
+3524,3524,3525
+3525,3525,3526
+3526,3526,3527
+3527,3527,3528
+3528,3528,3529
+3529,3529,3530
+3530,3530,3531
+3531,3531,3532
+3532,3532,3533
+3533,3533,3534
+3534,3534,3535
+3535,3535,3536
+3536,3536,3537
+3537,3537,3538
+3538,3538,3539
+3539,3539,3540
+3540,3540,3541
+3541,3541,3542
+3542,3542,3543
+3543,3543,3544
+3544,3544,3545
+3545,3545,3546
+3546,3546,3547
+3547,3547,3548
+3548,3548,3549
+3549,3549,3550
+3550,3550,3551
+3551,3551,3552
+3552,3552,3553
+3553,3553,3554
+3554,3554,3555
+3555,3555,3556
+3556,3556,3557
+3557,3557,3558
+3558,3558,3559
+3559,3559,3560
+3560,3560,3561
+3561,3561,3562
+3562,3562,3563
+3563,3563,3564
+3564,3564,3565
+3565,3565,3566
+3566,3566,3567
+3567,3567,3568
+3568,3568,3569
+3569,3569,3570
+3570,3570,3571
+3571,3571,3572
+3572,3572,3573
+3573,3573,3574
+3574,3574,3575
+3575,3575,3576
+3576,3576,3577
+3577,3577,3578
+3578,3578,3579
+3579,3579,3580
+3580,3580,3581
+3581,3581,3582
+3582,3582,3583
+3583,3583,3584
+3584,3584,3585
+3585,3585,3586
+3586,3586,3587
+3587,3587,3588
+3588,3588,3589
+3589,3589,3590
+3590,3590,3591
+3591,3591,3592
+3592,3592,3593
+3593,3593,3594
+3594,3594,3595
+3595,3595,3596
+3596,3596,3597
+3597,3597,3598
+3598,3598,3599
+3599,3599,3600
+3600,3600,3601
+3601,3601,3602
+3602,3602,3603
+3603,3603,3604
+3604,3604,3605
+3605,3605,3606
+3606,3606,3607
+3607,3607,3608
+3608,3608,3609
+3609,3609,3610
+3610,3610,3611
+3611,3611,3612
+3612,3612,3613
+3613,3613,3614
+3614,3614,3615
+3615,3615,3616
+3616,3616,3617
+3617,3617,3618
+3618,3618,3619
+3619,3619,3620
+3620,3620,3621
+3621,3621,3622
+3622,3622,3623
+3623,3623,3624
+3624,3624,3625
+3625,3625,3626
+3626,3626,3627
+3627,3627,3628
+3628,3628,3629
+3629,3629,3630
+3630,3630,3631
+3631,3631,3632
+3632,3632,3633
+3633,3633,3634
+3634,3634,3635
+3635,3635,3636
+3636,3636,3637
+3637,3637,3638
+3638,3638,3639
+3639,3639,3640
+3640,3640,3641
+3641,3641,3642
+3642,3642,3643
+3643,3643,3644
+3644,3644,3645
+3645,3645,3646
+3646,3646,3647
+3647,3647,3648
+3648,3648,3649
+3649,3649,3650
+3650,3650,3651
+3651,3651,3652
+3652,3652,3653
+3653,3653,3654
+3654,3654,3655
+3655,3655,3656
+3656,3656,3657
+3657,3657,3658
+3658,3658,3659
+3659,3659,3660
+3660,3660,3661
+3661,3661,3662
+3662,3662,3663
+3663,3663,3664
+3664,3664,3665
+3665,3665,3666
+3666,3666,3667
+3667,3667,3668
+3668,3668,3669
+3669,3669,3670
+3670,3670,3671
+3671,3671,3672
+3672,3672,3673
+3673,3673,3674
+3674,3674,3675
+3675,3675,3676
+3676,3676,3677
+3677,3677,3678
+3678,3678,3679
+3679,3679,3680
+3680,3680,3681
+3681,3681,3682
+3682,3682,3683
+3683,3683,3684
+3684,3684,3685
+3685,3685,3686
+3686,3686,3687
+3687,3687,3688
+3688,3688,3689
+3689,3689,3690
+3690,3690,3691
+3691,3691,3692
+3692,3692,3693
+3693,3693,3694
+3694,3694,3695
+3695,3695,3696
+3696,3696,3697
+3697,3697,3698
+3698,3698,3699
+3699,3699,3700
+3700,3700,3701
+3701,3701,3702
+3702,3702,3703
+3703,3703,3704
+3704,3704,3705
+3705,3705,3706
+3706,3706,3707
+3707,3707,3708
+3708,3708,3709
+3709,3709,3710
+3710,3710,3711
+3711,3711,3712
+3712,3712,3713
+3713,3713,3714
+3714,3714,3715
+3715,3715,3716
+3716,3716,3717
+3717,3717,3718
+3718,3718,3719
+3719,3719,3720
+3720,3720,3721
+3721,3721,3722
+3722,3722,3723
+3723,3723,3724
+3724,3724,3725
+3725,3725,3726
+3726,3726,3727
+3727,3727,3728
+3728,3728,3729
+3729,3729,3730
+3730,3730,3731
+3731,3731,3732
+3732,3732,3733
+3733,3733,3734
+3734,3734,3735
+3735,3735,3736
+3736,3736,3737
+3737,3737,3738
+3738,3738,3739
+3739,3739,3740
+3740,3740,3741
+3741,3741,3742
+3742,3742,3743
+3743,3743,3744
+3744,3744,3745
+3745,3745,3746
+3746,3746,3747
+3747,3747,3748
+3748,3748,3749
+3749,3749,3750
+3750,3750,3751
+3751,3751,3752
+3752,3752,3753
+3753,3753,3754
+3754,3754,3755
+3755,3755,3756
+3756,3756,3757
+3757,3757,3758
+3758,3758,3759
+3759,3759,3760
+3760,3760,3761
+3761,3761,3762
+3762,3762,3763
+3763,3763,3764
+3764,3764,3765
+3765,3765,3766
+3766,3766,3767
+3767,3767,3768
+3768,3768,3769
+3769,3769,3770
+3770,3770,3771
+3771,3771,3772
+3772,3772,3773
+3773,3773,3774
+3774,3774,3775
+3775,3775,3776
+3776,3776,3777
+3777,3777,3778
+3778,3778,3779
+3779,3779,3780
+3780,3780,3781
+3781,3781,3782
+3782,3782,3783
+3783,3783,3784
+3784,3784,3785
+3785,3785,3786
+3786,3786,3787
+3787,3787,3788
+3788,3788,3789
+3789,3789,3790
+3790,3790,3791
+3791,3791,3792
+3792,3792,3793
+3793,3793,3794
+3794,3794,3795
+3795,3795,3796
+3796,3796,3797
+3797,3797,3798
+3798,3798,3799
+3799,3799,3800
+3800,3800,3801
+3801,3801,3802
+3802,3802,3803
+3803,3803,3804
+3804,3804,3805
+3805,3805,3806
+3806,3806,3807
+3807,3807,3808
+3808,3808,3809
+3809,3809,3810
+3810,3810,3811
+3811,3811,3812
+3812,3812,3813
+3813,3813,3814
+3814,3814,3815
+3815,3815,3816
+3816,3816,3817
+3817,3817,3818
+3818,3818,3819
+3819,3819,3820
+3820,3820,3821
+3821,3821,3822
+3822,3822,3823
+3823,3823,3824
+3824,3824,3825
+3825,3825,3826
+3826,3826,3827
+3827,3827,3828
+3828,3828,3829
+3829,3829,3830
+3830,3830,3831
+3831,3831,3832
+3832,3832,3833
+3833,3833,3834
+3834,3834,3835
+3835,3835,3836
+3836,3836,3837
+3837,3837,3838
+3838,3838,3839
+3839,3839,3840
+3840,3840,3841
+3841,3841,3842
+3842,3842,3843
+3843,3843,3844
+3844,3844,3845
+3845,3845,3846
+3846,3846,3847
+3847,3847,3848
+3848,3848,3849
+3849,3849,3850
+3850,3850,3851
+3851,3851,3852
+3852,3852,3853
+3853,3853,3854
+3854,3854,3855
+3855,3855,3856
+3856,3856,3857
+3857,3857,3858
+3858,3858,3859
+3859,3859,3860
+3860,3860,3861
+3861,3861,3862
+3862,3862,3863
+3863,3863,3864
+3864,3864,3865
+3865,3865,3866
+3866,3866,3867
+3867,3867,3868
+3868,3868,3869
+3869,3869,3870
+3870,3870,3871
+3871,3871,3872
+3872,3872,3873
+3873,3873,3874
+3874,3874,3875
+3875,3875,3876
+3876,3876,3877
+3877,3877,3878
+3878,3878,3879
+3879,3879,3880
+3880,3880,3881
+3881,3881,3882
+3882,3882,3883
+3883,3883,3884
+3884,3884,3885
+3885,3885,3886
+3886,3886,3887
+3887,3887,3888
+3888,3888,3889
+3889,3889,3890
+3890,3890,3891
+3891,3891,3892
+3892,3892,3893
+3893,3893,3894
+3894,3894,3895
+3895,3895,3896
+3896,3896,3897
+3897,3897,3898
+3898,3898,3899
+3899,3899,3900
+3900,3900,3901
+3901,3901,3902
+3902,3902,3903
+3903,3903,3904
+3904,3904,3905
+3905,3905,3906
+3906,3906,3907
+3907,3907,3908
+3908,3908,3909
+3909,3909,3910
+3910,3910,3911
+3911,3911,3912
+3912,3912,3913
+3913,3913,3914
+3914,3914,3915
+3915,3915,3916
+3916,3916,3917
+3917,3917,3918
+3918,3918,3919
+3919,3919,3920
+3920,3920,3921
+3921,3921,3922
+3922,3922,3923
+3923,3923,3924
+3924,3924,3925
+3925,3925,3926
+3926,3926,3927
+3927,3927,3928
+3928,3928,3929
+3929,3929,3930
+3930,3930,3931
+3931,3931,3932
+3932,3932,3933
+3933,3933,3934
+3934,3934,3935
+3935,3935,3936
+3936,3936,3937
+3937,3937,3938
+3938,3938,3939
+3939,3939,3940
+3940,3940,3941
+3941,3941,3942
+3942,3942,3943
+3943,3943,3944
+3944,3944,3945
+3945,3945,3946
+3946,3946,3947
+3947,3947,3948
+3948,3948,3949
+3949,3949,3950
+3950,3950,3951
+3951,3951,3952
+3952,3952,3953
+3953,3953,3954
+3954,3954,3955
+3955,3955,3956
+3956,3956,3957
+3957,3957,3958
+3958,3958,3959
+3959,3959,3960
+3960,3960,3961
+3961,3961,3962
+3962,3962,3963
+3963,3963,3964
+3964,3964,3965
+3965,3965,3966
+3966,3966,3967
+3967,3967,3968
+3968,3968,3969
+3969,3969,3970
+3970,3970,3971
+3971,3971,3972
+3972,3972,3973
+3973,3973,3974
+3974,3974,3975
+3975,3975,3976
+3976,3976,3977
+3977,3977,3978
+3978,3978,3979
+3979,3979,3980
+3980,3980,3981
+3981,3981,3982
+3982,3982,3983
+3983,3983,3984
+3984,3984,3985
+3985,3985,3986
+3986,3986,3987
+3987,3987,3988
+3988,3988,3989
+3989,3989,3990
+3990,3990,3991
+3991,3991,3992
+3992,3992,3993
+3993,3993,3994
+3994,3994,3995
+3995,3995,3996
+3996,3996,3997
+3997,3997,3998
+3998,3998,3999
+3999,3999,4000
+4000,4000,4001
+4001,4001,4002
+4002,4002,4003
+4003,4003,4004
+4004,4004,4005
+4005,4005,4006
+4006,4006,4007
+4007,4007,4008
+4008,4008,4009
+4009,4009,4010
+4010,4010,4011
+4011,4011,4012
+4012,4012,4013
+4013,4013,4014
+4014,4014,4015
+4015,4015,4016
+4016,4016,4017
+4017,4017,4018
+4018,4018,4019
+4019,4019,4020
+4020,4020,4021
+4021,4021,4022
+4022,4022,4023
+4023,4023,4024
+4024,4024,4025
+4025,4025,4026
+4026,4026,4027
+4027,4027,4028
+4028,4028,4029
+4029,4029,4030
+4030,4030,4031
+4031,4031,4032
+4032,4032,4033
+4033,4033,4034
+4034,4034,4035
+4035,4035,4036
+4036,4036,4037
+4037,4037,4038
+4038,4038,4039
+4039,4039,4040
+4040,4040,4041
+4041,4041,4042
+4042,4042,4043
+4043,4043,4044
+4044,4044,4045
+4045,4045,4046
+4046,4046,4047
+4047,4047,4048
+4048,4048,4049
+4049,4049,4050
+4050,4050,4051
+4051,4051,4052
+4052,4052,4053
+4053,4053,4054
+4054,4054,4055
+4055,4055,4056
+4056,4056,4057
+4057,4057,4058
+4058,4058,4059
+4059,4059,4060
+4060,4060,4061
+4061,4061,4062
+4062,4062,4063
+4063,4063,4064
+4064,4064,4065
+4065,4065,4066
+4066,4066,4067
+4067,4067,4068
+4068,4068,4069
+4069,4069,4070
+4070,4070,4071
+4071,4071,4072
+4072,4072,4073
+4073,4073,4074
+4074,4074,4075
+4075,4075,4076
+4076,4076,4077
+4077,4077,4078
+4078,4078,4079
+4079,4079,4080
+4080,4080,4081
+4081,4081,4082
+4082,4082,4083
+4083,4083,4084
+4084,4084,4085
+4085,4085,4086
+4086,4086,4087
+4087,4087,4088
+4088,4088,4089
+4089,4089,4090
+4090,4090,4091
+4091,4091,4092
+4092,4092,4093
+4093,4093,4094
+4094,4094,4095
+4095,4095,4096
+4096,4096,4097
+4097,4097,4098
+4098,4098,4099
+4099,4099,4100
+4100,4100,4101
+4101,4101,4102
+4102,4102,4103
+4103,4103,4104
+4104,4104,4105
+4105,4105,4106
+4106,4106,4107
+4107,4107,4108
+4108,4108,4109
+4109,4109,4110
+4110,4110,4111
+4111,4111,4112
+4112,4112,4113
+4113,4113,4114
+4114,4114,4115
+4115,4115,4116
+4116,4116,4117
+4117,4117,4118
+4118,4118,4119
+4119,4119,4120
+4120,4120,4121
+4121,4121,4122
+4122,4122,4123
+4123,4123,4124
+4124,4124,4125
+4125,4125,4126
+4126,4126,4127
+4127,4127,4128
+4128,4128,4129
+4129,4129,4130
+4130,4130,4131
+4131,4131,4132
+4132,4132,4133
+4133,4133,4134
+4134,4134,4135
+4135,4135,4136
+4136,4136,4137
+4137,4137,4138
+4138,4138,4139
+4139,4139,4140
+4140,4140,4141
+4141,4141,4142
+4142,4142,4143
+4143,4143,4144
+4144,4144,4145
+4145,4145,4146
+4146,4146,4147
+4147,4147,4148
+4148,4148,4149
+4149,4149,4150
+4150,4150,4151
+4151,4151,4152
+4152,4152,4153
+4153,4153,4154
+4154,4154,4155
+4155,4155,4156
+4156,4156,4157
+4157,4157,4158
+4158,4158,4159
+4159,4159,4160
+4160,4160,4161
+4161,4161,4162
+4162,4162,4163
+4163,4163,4164
+4164,4164,4165
+4165,4165,4166
+4166,4166,4167
+4167,4167,4168
+4168,4168,4169
+4169,4169,4170
+4170,4170,4171
+4171,4171,4172
+4172,4172,4173
+4173,4173,4174
+4174,4174,4175
+4175,4175,4176
+4176,4176,4177
+4177,4177,4178
+4178,4178,4179
+4179,4179,4180
+4180,4180,4181
+4181,4181,4182
+4182,4182,4183
+4183,4183,4184
+4184,4184,4185
+4185,4185,4186
+4186,4186,4187
+4187,4187,4188
+4188,4188,4189
+4189,4189,4190
+4190,4190,4191
+4191,4191,4192
+4192,4192,4193
+4193,4193,4194
+4194,4194,4195
+4195,4195,4196
+4196,4196,4197
+4197,4197,4198
+4198,4198,4199
+4199,4199,4200
+4200,4200,4201
+4201,4201,4202
+4202,4202,4203
+4203,4203,4204
+4204,4204,4205
+4205,4205,4206
+4206,4206,4207
+4207,4207,4208
+4208,4208,4209
+4209,4209,4210
+4210,4210,4211
+4211,4211,4212
+4212,4212,4213
+4213,4213,4214
+4214,4214,4215
+4215,4215,4216
+4216,4216,4217
+4217,4217,4218
+4218,4218,4219
+4219,4219,4220
+4220,4220,4221
+4221,4221,4222
+4222,4222,4223
+4223,4223,4224
+4224,4224,4225
+4225,4225,4226
+4226,4226,4227
+4227,4227,4228
+4228,4228,4229
+4229,4229,4230
+4230,4230,4231
+4231,4231,4232
+4232,4232,4233
+4233,4233,4234
+4234,4234,4235
+4235,4235,4236
+4236,4236,4237
+4237,4237,4238
+4238,4238,4239
+4239,4239,4240
+4240,4240,4241
+4241,4241,4242
+4242,4242,4243
+4243,4243,4244
+4244,4244,4245
+4245,4245,4246
+4246,4246,4247
+4247,4247,4248
+4248,4248,4249
+4249,4249,4250
+4250,4250,4251
+4251,4251,4252
+4252,4252,4253
+4253,4253,4254
+4254,4254,4255
+4255,4255,4256
+4256,4256,4257
+4257,4257,4258
+4258,4258,4259
+4259,4259,4260
+4260,4260,4261
+4261,4261,4262
+4262,4262,4263
+4263,4263,4264
+4264,4264,4265
+4265,4265,4266
+4266,4266,4267
+4267,4267,4268
+4268,4268,4269
+4269,4269,4270
+4270,4270,4271
+4271,4271,4272
+4272,4272,4273
+4273,4273,4274
+4274,4274,4275
+4275,4275,4276
+4276,4276,4277
+4277,4277,4278
+4278,4278,4279
+4279,4279,4280
+4280,4280,4281
+4281,4281,4282
+4282,4282,4283
+4283,4283,4284
+4284,4284,4285
+4285,4285,4286
+4286,4286,4287
+4287,4287,4288
+4288,4288,4289
+4289,4289,4290
+4290,4290,4291
+4291,4291,4292
+4292,4292,4293
+4293,4293,4294
+4294,4294,4295
+4295,4295,4296
+4296,4296,4297
+4297,4297,4298
+4298,4298,4299
+4299,4299,4300
+4300,4300,4301
+4301,4301,4302
+4302,4302,4303
+4303,4303,4304
+4304,4304,4305
+4305,4305,4306
+4306,4306,4307
+4307,4307,4308
+4308,4308,4309
+4309,4309,4310
+4310,4310,4311
+4311,4311,4312
+4312,4312,4313
+4313,4313,4314
+4314,4314,4315
+4315,4315,4316
+4316,4316,4317
+4317,4317,4318
+4318,4318,4319
+4319,4319,4320
+4320,4320,4321
+4321,4321,4322
+4322,4322,4323
+4323,4323,4324
+4324,4324,4325
+4325,4325,4326
+4326,4326,4327
+4327,4327,4328
+4328,4328,4329
+4329,4329,4330
+4330,4330,4331
+4331,4331,4332
+4332,4332,4333
+4333,4333,4334
+4334,4334,4335
+4335,4335,4336
+4336,4336,4337
+4337,4337,4338
+4338,4338,4339
+4339,4339,4340
+4340,4340,4341
+4341,4341,4342
+4342,4342,4343
+4343,4343,4344
+4344,4344,4345
+4345,4345,4346
+4346,4346,4347
+4347,4347,4348
+4348,4348,4349
+4349,4349,4350
+4350,4350,4351
+4351,4351,4352
+4352,4352,4353
+4353,4353,4354
+4354,4354,4355
+4355,4355,4356
+4356,4356,4357
+4357,4357,4358
+4358,4358,4359
+4359,4359,4360
+4360,4360,4361
+4361,4361,4362
+4362,4362,4363
+4363,4363,4364
+4364,4364,4365
+4365,4365,4366
+4366,4366,4367
+4367,4367,4368
+4368,4368,4369
+4369,4369,4370
+4370,4370,4371
+4371,4371,4372
+4372,4372,4373
+4373,4373,4374
+4374,4374,4375
+4375,4375,4376
+4376,4376,4377
+4377,4377,4378
+4378,4378,4379
+4379,4379,4380
+4380,4380,4381
+4381,4381,4382
+4382,4382,4383
+4383,4383,4384
+4384,4384,4385
+4385,4385,4386
+4386,4386,4387
+4387,4387,4388
+4388,4388,4389
+4389,4389,4390
+4390,4390,4391
+4391,4391,4392
+4392,4392,4393
+4393,4393,4394
+4394,4394,4395
+4395,4395,4396
+4396,4396,4397
+4397,4397,4398
+4398,4398,4399
+4399,4399,4400
+4400,4400,4401
+4401,4401,4402
+4402,4402,4403
+4403,4403,4404
+4404,4404,4405
+4405,4405,4406
+4406,4406,4407
+4407,4407,4408
+4408,4408,4409
+4409,4409,4410
+4410,4410,4411
+4411,4411,4412
+4412,4412,4413
+4413,4413,4414
+4414,4414,4415
+4415,4415,4416
+4416,4416,4417
+4417,4417,4418
+4418,4418,4419
+4419,4419,4420
+4420,4420,4421
+4421,4421,4422
+4422,4422,4423
+4423,4423,4424
+4424,4424,4425
+4425,4425,4426
+4426,4426,4427
+4427,4427,4428
+4428,4428,4429
+4429,4429,4430
+4430,4430,4431
+4431,4431,4432
+4432,4432,4433
+4433,4433,4434
+4434,4434,4435
+4435,4435,4436
+4436,4436,4437
+4437,4437,4438
+4438,4438,4439
+4439,4439,4440
+4440,4440,4441
+4441,4441,4442
+4442,4442,4443
+4443,4443,4444
+4444,4444,4445
+4445,4445,4446
+4446,4446,4447
+4447,4447,4448
+4448,4448,4449
+4449,4449,4450
+4450,4450,4451
+4451,4451,4452
+4452,4452,4453
+4453,4453,4454
+4454,4454,4455
+4455,4455,4456
+4456,4456,4457
+4457,4457,4458
+4458,4458,4459
+4459,4459,4460
+4460,4460,4461
+4461,4461,4462
+4462,4462,4463
+4463,4463,4464
+4464,4464,4465
+4465,4465,4466
+4466,4466,4467
+4467,4467,4468
+4468,4468,4469
+4469,4469,4470
+4470,4470,4471
+4471,4471,4472
+4472,4472,4473
+4473,4473,4474
+4474,4474,4475
+4475,4475,4476
+4476,4476,4477
+4477,4477,4478
+4478,4478,4479
+4479,4479,4480
+4480,4480,4481
+4481,4481,4482
+4482,4482,4483
+4483,4483,4484
+4484,4484,4485
+4485,4485,4486
+4486,4486,4487
+4487,4487,4488
+4488,4488,4489
+4489,4489,4490
+4490,4490,4491
+4491,4491,4492
+4492,4492,4493
+4493,4493,4494
+4494,4494,4495
+4495,4495,4496
+4496,4496,4497
+4497,4497,4498
+4498,4498,4499
+4499,4499,4500
+4500,4500,4501
+4501,4501,4502
+4502,4502,4503
+4503,4503,4504
+4504,4504,4505
+4505,4505,4506
+4506,4506,4507
+4507,4507,4508
+4508,4508,4509
+4509,4509,4510
+4510,4510,4511
+4511,4511,4512
+4512,4512,4513
+4513,4513,4514
+4514,4514,4515
+4515,4515,4516
+4516,4516,4517
+4517,4517,4518
+4518,4518,4519
+4519,4519,4520
+4520,4520,4521
+4521,4521,4522
+4522,4522,4523
+4523,4523,4524
+4524,4524,4525
+4525,4525,4526
+4526,4526,4527
+4527,4527,4528
+4528,4528,4529
+4529,4529,4530
+4530,4530,4531
+4531,4531,4532
+4532,4532,4533
+4533,4533,4534
+4534,4534,4535
+4535,4535,4536
+4536,4536,4537
+4537,4537,4538
+4538,4538,4539
+4539,4539,4540
+4540,4540,4541
+4541,4541,4542
+4542,4542,4543
+4543,4543,4544
+4544,4544,4545
+4545,4545,4546
+4546,4546,4547
+4547,4547,4548
+4548,4548,4549
+4549,4549,4550
+4550,4550,4551
+4551,4551,4552
+4552,4552,4553
+4553,4553,4554
+4554,4554,4555
+4555,4555,4556
+4556,4556,4557
+4557,4557,4558
+4558,4558,4559
+4559,4559,4560
+4560,4560,4561
+4561,4561,4562
+4562,4562,4563
+4563,4563,4564
+4564,4564,4565
+4565,4565,4566
+4566,4566,4567
+4567,4567,4568
+4568,4568,4569
+4569,4569,4570
+4570,4570,4571
+4571,4571,4572
+4572,4572,4573
+4573,4573,4574
+4574,4574,4575
+4575,4575,4576
+4576,4576,4577
+4577,4577,4578
+4578,4578,4579
+4579,4579,4580
+4580,4580,4581
+4581,4581,4582
+4582,4582,4583
+4583,4583,4584
+4584,4584,4585
+4585,4585,4586
+4586,4586,4587
+4587,4587,4588
+4588,4588,4589
+4589,4589,4590
+4590,4590,4591
+4591,4591,4592
+4592,4592,4593
+4593,4593,4594
+4594,4594,4595
+4595,4595,4596
+4596,4596,4597
+4597,4597,4598
+4598,4598,4599
+4599,4599,4600
+4600,4600,4601
+4601,4601,4602
+4602,4602,4603
+4603,4603,4604
+4604,4604,4605
+4605,4605,4606
+4606,4606,4607
+4607,4607,4608
+4608,4608,4609
+4609,4609,4610
+4610,4610,4611
+4611,4611,4612
+4612,4612,4613
+4613,4613,4614
+4614,4614,4615
+4615,4615,4616
+4616,4616,4617
+4617,4617,4618
+4618,4618,4619
+4619,4619,4620
+4620,4620,4621
+4621,4621,4622
+4622,4622,4623
+4623,4623,4624
+4624,4624,4625
+4625,4625,4626
+4626,4626,4627
+4627,4627,4628
+4628,4628,4629
+4629,4629,4630
+4630,4630,4631
+4631,4631,4632
+4632,4632,4633
+4633,4633,4634
+4634,4634,4635
+4635,4635,4636
+4636,4636,4637
+4637,4637,4638
+4638,4638,4639
+4639,4639,4640
+4640,4640,4641
+4641,4641,4642
+4642,4642,4643
+4643,4643,4644
+4644,4644,4645
+4645,4645,4646
+4646,4646,4647
+4647,4647,4648
+4648,4648,4649
+4649,4649,4650
+4650,4650,4651
+4651,4651,4652
+4652,4652,4653
+4653,4653,4654
+4654,4654,4655
+4655,4655,4656
+4656,4656,4657
+4657,4657,4658
+4658,4658,4659
+4659,4659,4660
+4660,4660,4661
+4661,4661,4662
+4662,4662,4663
+4663,4663,4664
+4664,4664,4665
+4665,4665,4666
+4666,4666,4667
+4667,4667,4668
+4668,4668,4669
+4669,4669,4670
+4670,4670,4671
+4671,4671,4672
+4672,4672,4673
+4673,4673,4674
+4674,4674,4675
+4675,4675,4676
+4676,4676,4677
+4677,4677,4678
+4678,4678,4679
+4679,4679,4680
+4680,4680,4681
+4681,4681,4682
+4682,4682,4683
+4683,4683,4684
+4684,4684,4685
+4685,4685,4686
+4686,4686,4687
+4687,4687,4688
+4688,4688,4689
+4689,4689,4690
+4690,4690,4691
+4691,4691,4692
+4692,4692,4693
+4693,4693,4694
+4694,4694,4695
+4695,4695,4696
+4696,4696,4697
+4697,4697,4698
+4698,4698,4699
+4699,4699,4700
+4700,4700,4701
+4701,4701,4702
+4702,4702,4703
+4703,4703,4704
+4704,4704,4705
+4705,4705,4706
+4706,4706,4707
+4707,4707,4708
+4708,4708,4709
+4709,4709,4710
+4710,4710,4711
+4711,4711,4712
+4712,4712,4713
+4713,4713,4714
+4714,4714,4715
+4715,4715,4716
+4716,4716,4717
+4717,4717,4718
+4718,4718,4719
+4719,4719,4720
+4720,4720,4721
+4721,4721,4722
+4722,4722,4723
+4723,4723,4724
+4724,4724,4725
+4725,4725,4726
+4726,4726,4727
+4727,4727,4728
+4728,4728,4729
+4729,4729,4730
+4730,4730,4731
+4731,4731,4732
+4732,4732,4733
+4733,4733,4734
+4734,4734,4735
+4735,4735,4736
+4736,4736,4737
+4737,4737,4738
+4738,4738,4739
+4739,4739,4740
+4740,4740,4741
+4741,4741,4742
+4742,4742,4743
+4743,4743,4744
+4744,4744,4745
+4745,4745,4746
+4746,4746,4747
+4747,4747,4748
+4748,4748,4749
+4749,4749,4750
+4750,4750,4751
+4751,4751,4752
+4752,4752,4753
+4753,4753,4754
+4754,4754,4755
+4755,4755,4756
+4756,4756,4757
+4757,4757,4758
+4758,4758,4759
+4759,4759,4760
+4760,4760,4761
+4761,4761,4762
+4762,4762,4763
+4763,4763,4764
+4764,4764,4765
+4765,4765,4766
+4766,4766,4767
+4767,4767,4768
+4768,4768,4769
+4769,4769,4770
+4770,4770,4771
+4771,4771,4772
+4772,4772,4773
+4773,4773,4774
+4774,4774,4775
+4775,4775,4776
+4776,4776,4777
+4777,4777,4778
+4778,4778,4779
+4779,4779,4780
+4780,4780,4781
+4781,4781,4782
+4782,4782,4783
+4783,4783,4784
+4784,4784,4785
+4785,4785,4786
+4786,4786,4787
+4787,4787,4788
+4788,4788,4789
+4789,4789,4790
+4790,4790,4791
+4791,4791,4792
+4792,4792,4793
+4793,4793,4794
+4794,4794,4795
+4795,4795,4796
+4796,4796,4797
+4797,4797,4798
+4798,4798,4799
+4799,4799,4800
+4800,4800,4801
+4801,4801,4802
+4802,4802,4803
+4803,4803,4804
+4804,4804,4805
+4805,4805,4806
+4806,4806,4807
+4807,4807,4808
+4808,4808,4809
+4809,4809,4810
+4810,4810,4811
+4811,4811,4812
+4812,4812,4813
+4813,4813,4814
+4814,4814,4815
+4815,4815,4816
+4816,4816,4817
+4817,4817,4818
+4818,4818,4819
+4819,4819,4820
+4820,4820,4821
+4821,4821,4822
+4822,4822,4823
+4823,4823,4824
+4824,4824,4825
+4825,4825,4826
+4826,4826,4827
+4827,4827,4828
+4828,4828,4829
+4829,4829,4830
+4830,4830,4831
+4831,4831,4832
+4832,4832,4833
+4833,4833,4834
+4834,4834,4835
+4835,4835,4836
+4836,4836,4837
+4837,4837,4838
+4838,4838,4839
+4839,4839,4840
+4840,4840,4841
+4841,4841,4842
+4842,4842,4843
+4843,4843,4844
+4844,4844,4845
+4845,4845,4846
+4846,4846,4847
+4847,4847,4848
+4848,4848,4849
+4849,4849,4850
+4850,4850,4851
+4851,4851,4852
+4852,4852,4853
+4853,4853,4854
+4854,4854,4855
+4855,4855,4856
+4856,4856,4857
+4857,4857,4858
+4858,4858,4859
+4859,4859,4860
+4860,4860,4861
+4861,4861,4862
+4862,4862,4863
+4863,4863,4864
+4864,4864,4865
+4865,4865,4866
+4866,4866,4867
+4867,4867,4868
+4868,4868,4869
+4869,4869,4870
+4870,4870,4871
+4871,4871,4872
+4872,4872,4873
+4873,4873,4874
+4874,4874,4875
+4875,4875,4876
+4876,4876,4877
+4877,4877,4878
+4878,4878,4879
+4879,4879,4880
+4880,4880,4881
+4881,4881,4882
+4882,4882,4883
+4883,4883,4884
+4884,4884,4885
+4885,4885,4886
+4886,4886,4887
+4887,4887,4888
+4888,4888,4889
+4889,4889,4890
+4890,4890,4891
+4891,4891,4892
+4892,4892,4893
+4893,4893,4894
+4894,4894,4895
+4895,4895,4896
+4896,4896,4897
+4897,4897,4898
+4898,4898,4899
+4899,4899,4900
+4900,4900,4901
+4901,4901,4902
+4902,4902,4903
+4903,4903,4904
+4904,4904,4905
+4905,4905,4906
+4906,4906,4907
+4907,4907,4908
+4908,4908,4909
+4909,4909,4910
+4910,4910,4911
+4911,4911,4912
+4912,4912,4913
+4913,4913,4914
+4914,4914,4915
+4915,4915,4916
+4916,4916,4917
+4917,4917,4918
+4918,4918,4919
+4919,4919,4920
+4920,4920,4921
+4921,4921,4922
+4922,4922,4923
+4923,4923,4924
+4924,4924,4925
+4925,4925,4926
+4926,4926,4927
+4927,4927,4928
+4928,4928,4929
+4929,4929,4930
+4930,4930,4931
+4931,4931,4932
+4932,4932,4933
+4933,4933,4934
+4934,4934,4935
+4935,4935,4936
+4936,4936,4937
+4937,4937,4938
+4938,4938,4939
+4939,4939,4940
+4940,4940,4941
+4941,4941,4942
+4942,4942,4943
+4943,4943,4944
+4944,4944,4945
+4945,4945,4946
+4946,4946,4947
+4947,4947,4948
+4948,4948,4949
+4949,4949,4950
+4950,4950,4951
+4951,4951,4952
+4952,4952,4953
+4953,4953,4954
+4954,4954,4955
+4955,4955,4956
+4956,4956,4957
+4957,4957,4958
+4958,4958,4959
+4959,4959,4960
+4960,4960,4961
+4961,4961,4962
+4962,4962,4963
+4963,4963,4964
+4964,4964,4965
+4965,4965,4966
+4966,4966,4967
+4967,4967,4968
+4968,4968,4969
+4969,4969,4970
+4970,4970,4971
+4971,4971,4972
+4972,4972,4973
+4973,4973,4974
+4974,4974,4975
+4975,4975,4976
+4976,4976,4977
+4977,4977,4978
+4978,4978,4979
+4979,4979,4980
+4980,4980,4981
+4981,4981,4982
+4982,4982,4983
+4983,4983,4984
+4984,4984,4985
+4985,4985,4986
+4986,4986,4987
+4987,4987,4988
+4988,4988,4989
+4989,4989,4990
+4990,4990,4991
+4991,4991,4992
+4992,4992,4993
+4993,4993,4994
+4994,4994,4995
+4995,4995,4996
+4996,4996,4997
+4997,4997,4998
+4998,4998,4999
+4999,4999,5000
+5000,5000,5001
+5001,5001,5002
+5002,5002,5003
+5003,5003,5004
+5004,5004,5005
+5005,5005,5006
+5006,5006,5007
+5007,5007,5008
+5008,5008,5009
+5009,5009,5010
+5010,5010,5011
+5011,5011,5012
+5012,5012,5013
+5013,5013,5014
+5014,5014,5015
+5015,5015,5016
+5016,5016,5017
+5017,5017,5018
+5018,5018,5019
+5019,5019,5020
+5020,5020,5021
+5021,5021,5022
+5022,5022,5023
+5023,5023,5024
+5024,5024,5025
+5025,5025,5026
+5026,5026,5027
+5027,5027,5028
+5028,5028,5029
+5029,5029,5030
+5030,5030,5031
+5031,5031,5032
+5032,5032,5033
+5033,5033,5034
+5034,5034,5035
+5035,5035,5036
+5036,5036,5037
+5037,5037,5038
+5038,5038,5039
+5039,5039,5040
+5040,5040,5041
+5041,5041,5042
+5042,5042,5043
+5043,5043,5044
+5044,5044,5045
+5045,5045,5046
+5046,5046,5047
+5047,5047,5048
+5048,5048,5049
+5049,5049,5050
+5050,5050,5051
+5051,5051,5052
+5052,5052,5053
+5053,5053,5054
+5054,5054,5055
+5055,5055,5056
+5056,5056,5057
+5057,5057,5058
+5058,5058,5059
+5059,5059,5060
+5060,5060,5061
+5061,5061,5062
+5062,5062,5063
+5063,5063,5064
+5064,5064,5065
+5065,5065,5066
+5066,5066,5067
+5067,5067,5068
+5068,5068,5069
+5069,5069,5070
+5070,5070,5071
+5071,5071,5072
+5072,5072,5073
+5073,5073,5074
+5074,5074,5075
+5075,5075,5076
+5076,5076,5077
+5077,5077,5078
+5078,5078,5079
+5079,5079,5080
+5080,5080,5081
+5081,5081,5082
+5082,5082,5083
+5083,5083,5084
+5084,5084,5085
+5085,5085,5086
+5086,5086,5087
+5087,5087,5088
+5088,5088,5089
+5089,5089,5090
+5090,5090,5091
+5091,5091,5092
+5092,5092,5093
+5093,5093,5094
+5094,5094,5095
+5095,5095,5096
+5096,5096,5097
+5097,5097,5098
+5098,5098,5099
+5099,5099,5100
+5100,5100,5101
+5101,5101,5102
+5102,5102,5103
+5103,5103,5104
+5104,5104,5105
+5105,5105,5106
+5106,5106,5107
+5107,5107,5108
+5108,5108,5109
+5109,5109,5110
+5110,5110,5111
+5111,5111,5112
+5112,5112,5113
+5113,5113,5114
+5114,5114,5115
+5115,5115,5116
+5116,5116,5117
+5117,5117,5118
+5118,5118,5119
+5119,5119,5120
+5120,5120,5121
+5121,5121,5122
+5122,5122,5123
+5123,5123,5124
+5124,5124,5125
+5125,5125,5126
+5126,5126,5127
+5127,5127,5128
+5128,5128,5129
+5129,5129,5130
+5130,5130,5131
+5131,5131,5132
+5132,5132,5133
+5133,5133,5134
+5134,5134,5135
+5135,5135,5136
+5136,5136,5137
+5137,5137,5138
+5138,5138,5139
+5139,5139,5140
+5140,5140,5141
+5141,5141,5142
+5142,5142,5143
+5143,5143,5144
+5144,5144,5145
+5145,5145,5146
+5146,5146,5147
+5147,5147,5148
+5148,5148,5149
+5149,5149,5150
+5150,5150,5151
+5151,5151,5152
+5152,5152,5153
+5153,5153,5154
+5154,5154,5155
+5155,5155,5156
+5156,5156,5157
+5157,5157,5158
+5158,5158,5159
+5159,5159,5160
+5160,5160,5161
+5161,5161,5162
+5162,5162,5163
+5163,5163,5164
+5164,5164,5165
+5165,5165,5166
+5166,5166,5167
+5167,5167,5168
+5168,5168,5169
+5169,5169,5170
+5170,5170,5171
+5171,5171,5172
+5172,5172,5173
+5173,5173,5174
+5174,5174,5175
+5175,5175,5176
+5176,5176,5177
+5177,5177,5178
+5178,5178,5179
+5179,5179,5180
+5180,5180,5181
+5181,5181,5182
+5182,5182,5183
+5183,5183,5184
+5184,5184,5185
+5185,5185,5186
+5186,5186,5187
+5187,5187,5188
+5188,5188,5189
+5189,5189,5190
+5190,5190,5191
+5191,5191,5192
+5192,5192,5193
+5193,5193,5194
+5194,5194,5195
+5195,5195,5196
+5196,5196,5197
+5197,5197,5198
+5198,5198,5199
+5199,5199,5200
+5200,5200,5201
+5201,5201,5202
+5202,5202,5203
+5203,5203,5204
+5204,5204,5205
+5205,5205,5206
+5206,5206,5207
+5207,5207,5208
+5208,5208,5209
+5209,5209,5210
+5210,5210,5211
+5211,5211,5212
+5212,5212,5213
+5213,5213,5214
+5214,5214,5215
+5215,5215,5216
+5216,5216,5217
+5217,5217,5218
+5218,5218,5219
+5219,5219,5220
+5220,5220,5221
+5221,5221,5222
+5222,5222,5223
+5223,5223,5224
+5224,5224,5225
+5225,5225,5226
+5226,5226,5227
+5227,5227,5228
+5228,5228,5229
+5229,5229,5230
+5230,5230,5231
+5231,5231,5232
+5232,5232,5233
+5233,5233,5234
+5234,5234,5235
+5235,5235,5236
+5236,5236,5237
+5237,5237,5238
+5238,5238,5239
+5239,5239,5240
+5240,5240,5241
+5241,5241,5242
+5242,5242,5243
+5243,5243,5244
+5244,5244,5245
+5245,5245,5246
+5246,5246,5247
+5247,5247,5248
+5248,5248,5249
+5249,5249,5250
+5250,5250,5251
+5251,5251,5252
+5252,5252,5253
+5253,5253,5254
+5254,5254,5255
+5255,5255,5256
+5256,5256,5257
+5257,5257,5258
+5258,5258,5259
+5259,5259,5260
+5260,5260,5261
+5261,5261,5262
+5262,5262,5263
+5263,5263,5264
+5264,5264,5265
+5265,5265,5266
+5266,5266,5267
+5267,5267,5268
+5268,5268,5269
+5269,5269,5270
+5270,5270,5271
+5271,5271,5272
+5272,5272,5273
+5273,5273,5274
+5274,5274,5275
+5275,5275,5276
+5276,5276,5277
+5277,5277,5278
+5278,5278,5279
+5279,5279,5280
+5280,5280,5281
+5281,5281,5282
+5282,5282,5283
+5283,5283,5284
+5284,5284,5285
+5285,5285,5286
+5286,5286,5287
+5287,5287,5288
+5288,5288,5289
+5289,5289,5290
+5290,5290,5291
+5291,5291,5292
+5292,5292,5293
+5293,5293,5294
+5294,5294,5295
+5295,5295,5296
+5296,5296,5297
+5297,5297,5298
+5298,5298,5299
+5299,5299,5300
+5300,5300,5301
+5301,5301,5302
+5302,5302,5303
+5303,5303,5304
+5304,5304,5305
+5305,5305,5306
+5306,5306,5307
+5307,5307,5308
+5308,5308,5309
+5309,5309,5310
+5310,5310,5311
+5311,5311,5312
+5312,5312,5313
+5313,5313,5314
+5314,5314,5315
+5315,5315,5316
+5316,5316,5317
+5317,5317,5318
+5318,5318,5319
+5319,5319,5320
+5320,5320,5321
+5321,5321,5322
+5322,5322,5323
+5323,5323,5324
+5324,5324,5325
+5325,5325,5326
+5326,5326,5327
+5327,5327,5328
+5328,5328,5329
+5329,5329,5330
+5330,5330,5331
+5331,5331,5332
+5332,5332,5333
+5333,5333,5334
+5334,5334,5335
+5335,5335,5336
+5336,5336,5337
+5337,5337,5338
+5338,5338,5339
+5339,5339,5340
+5340,5340,5341
+5341,5341,5342
+5342,5342,5343
+5343,5343,5344
+5344,5344,5345
+5345,5345,5346
+5346,5346,5347
+5347,5347,5348
+5348,5348,5349
+5349,5349,5350
+5350,5350,5351
+5351,5351,5352
+5352,5352,5353
+5353,5353,5354
+5354,5354,5355
+5355,5355,5356
+5356,5356,5357
+5357,5357,5358
+5358,5358,5359
+5359,5359,5360
+5360,5360,5361
+5361,5361,5362
+5362,5362,5363
+5363,5363,5364
+5364,5364,5365
+5365,5365,5366
+5366,5366,5367
+5367,5367,5368
+5368,5368,5369
+5369,5369,5370
+5370,5370,5371
+5371,5371,5372
+5372,5372,5373
+5373,5373,5374
+5374,5374,5375
+5375,5375,5376
+5376,5376,5377
+5377,5377,5378
+5378,5378,5379
+5379,5379,5380
+5380,5380,5381
+5381,5381,5382
+5382,5382,5383
+5383,5383,5384
+5384,5384,5385
+5385,5385,5386
+5386,5386,5387
+5387,5387,5388
+5388,5388,5389
+5389,5389,5390
+5390,5390,5391
+5391,5391,5392
+5392,5392,5393
+5393,5393,5394
+5394,5394,5395
+5395,5395,5396
+5396,5396,5397
+5397,5397,5398
+5398,5398,5399
+5399,5399,5400
+5400,5400,5401
+5401,5401,5402
+5402,5402,5403
+5403,5403,5404
+5404,5404,5405
+5405,5405,5406
+5406,5406,5407
+5407,5407,5408
+5408,5408,5409
+5409,5409,5410
+5410,5410,5411
+5411,5411,5412
+5412,5412,5413
+5413,5413,5414
+5414,5414,5415
+5415,5415,5416
+5416,5416,5417
+5417,5417,5418
+5418,5418,5419
+5419,5419,5420
+5420,5420,5421
+5421,5421,5422
+5422,5422,5423
+5423,5423,5424
+5424,5424,5425
+5425,5425,5426
+5426,5426,5427
+5427,5427,5428
+5428,5428,5429
+5429,5429,5430
+5430,5430,5431
+5431,5431,5432
+5432,5432,5433
+5433,5433,5434
+5434,5434,5435
+5435,5435,5436
+5436,5436,5437
+5437,5437,5438
+5438,5438,5439
+5439,5439,5440
+5440,5440,5441
+5441,5441,5442
+5442,5442,5443
+5443,5443,5444
+5444,5444,5445
+5445,5445,5446
+5446,5446,5447
+5447,5447,5448
+5448,5448,5449
+5449,5449,5450
+5450,5450,5451
+5451,5451,5452
+5452,5452,5453
+5453,5453,5454
+5454,5454,5455
+5455,5455,5456
+5456,5456,5457
+5457,5457,5458
+5458,5458,5459
+5459,5459,5460
+5460,5460,5461
+5461,5461,5462
+5462,5462,5463
+5463,5463,5464
+5464,5464,5465
+5465,5465,5466
+5466,5466,5467
+5467,5467,5468
+5468,5468,5469
+5469,5469,5470
+5470,5470,5471
+5471,5471,5472
+5472,5472,5473
+5473,5473,5474
+5474,5474,5475
+5475,5475,5476
+5476,5476,5477
+5477,5477,5478
+5478,5478,5479
+5479,5479,5480
+5480,5480,5481
+5481,5481,5482
+5482,5482,5483
+5483,5483,5484
+5484,5484,5485
+5485,5485,5486
+5486,5486,5487
+5487,5487,5488
+5488,5488,5489
+5489,5489,5490
+5490,5490,5491
+5491,5491,5492
+5492,5492,5493
+5493,5493,5494
+5494,5494,5495
+5495,5495,5496
+5496,5496,5497
+5497,5497,5498
+5498,5498,5499
+5499,5499,5500
+5500,5500,5501
+5501,5501,5502
+5502,5502,5503
+5503,5503,5504
+5504,5504,5505
+5505,5505,5506
+5506,5506,5507
+5507,5507,5508
+5508,5508,5509
+5509,5509,5510
+5510,5510,5511
+5511,5511,5512
+5512,5512,5513
+5513,5513,5514
+5514,5514,5515
+5515,5515,5516
+5516,5516,5517
+5517,5517,5518
+5518,5518,5519
+5519,5519,5520
+5520,5520,5521
+5521,5521,5522
+5522,5522,5523
+5523,5523,5524
+5524,5524,5525
+5525,5525,5526
+5526,5526,5527
+5527,5527,5528
+5528,5528,5529
+5529,5529,5530
+5530,5530,5531
+5531,5531,5532
+5532,5532,5533
+5533,5533,5534
+5534,5534,5535
+5535,5535,5536
+5536,5536,5537
+5537,5537,5538
+5538,5538,5539
+5539,5539,5540
+5540,5540,5541
+5541,5541,5542
+5542,5542,5543
+5543,5543,5544
+5544,5544,5545
+5545,5545,5546
+5546,5546,5547
+5547,5547,5548
+5548,5548,5549
+5549,5549,5550
+5550,5550,5551
+5551,5551,5552
+5552,5552,5553
+5553,5553,5554
+5554,5554,5555
+5555,5555,5556
+5556,5556,5557
+5557,5557,5558
+5558,5558,5559
+5559,5559,5560
+5560,5560,5561
+5561,5561,5562
+5562,5562,5563
+5563,5563,5564
+5564,5564,5565
+5565,5565,5566
+5566,5566,5567
+5567,5567,5568
+5568,5568,5569
+5569,5569,5570
+5570,5570,5571
+5571,5571,5572
+5572,5572,5573
+5573,5573,5574
+5574,5574,5575
+5575,5575,5576
+5576,5576,5577
+5577,5577,5578
+5578,5578,5579
+5579,5579,5580
+5580,5580,5581
+5581,5581,5582
+5582,5582,5583
+5583,5583,5584
+5584,5584,5585
+5585,5585,5586
+5586,5586,5587
+5587,5587,5588
+5588,5588,5589
+5589,5589,5590
+5590,5590,5591
+5591,5591,5592
+5592,5592,5593
+5593,5593,5594
+5594,5594,5595
+5595,5595,5596
+5596,5596,5597
+5597,5597,5598
+5598,5598,5599
+5599,5599,5600
+5600,5600,5601
+5601,5601,5602
+5602,5602,5603
+5603,5603,5604
+5604,5604,5605
+5605,5605,5606
+5606,5606,5607
+5607,5607,5608
+5608,5608,5609
+5609,5609,5610
+5610,5610,5611
+5611,5611,5612
+5612,5612,5613
+5613,5613,5614
+5614,5614,5615
+5615,5615,5616
+5616,5616,5617
+5617,5617,5618
+5618,5618,5619
+5619,5619,5620
+5620,5620,5621
+5621,5621,5622
+5622,5622,5623
+5623,5623,5624
+5624,5624,5625
+5625,5625,5626
+5626,5626,5627
+5627,5627,5628
+5628,5628,5629
+5629,5629,5630
+5630,5630,5631
+5631,5631,5632
+5632,5632,5633
+5633,5633,5634
+5634,5634,5635
+5635,5635,5636
+5636,5636,5637
+5637,5637,5638
+5638,5638,5639
+5639,5639,5640
+5640,5640,5641
+5641,5641,5642
+5642,5642,5643
+5643,5643,5644
+5644,5644,5645
+5645,5645,5646
+5646,5646,5647
+5647,5647,5648
+5648,5648,5649
+5649,5649,5650
+5650,5650,5651
+5651,5651,5652
+5652,5652,5653
+5653,5653,5654
+5654,5654,5655
+5655,5655,5656
+5656,5656,5657
+5657,5657,5658
+5658,5658,5659
+5659,5659,5660
+5660,5660,5661
+5661,5661,5662
+5662,5662,5663
+5663,5663,5664
+5664,5664,5665
+5665,5665,5666
+5666,5666,5667
+5667,5667,5668
+5668,5668,5669
+5669,5669,5670
+5670,5670,5671
+5671,5671,5672
+5672,5672,5673
+5673,5673,5674
+5674,5674,5675
+5675,5675,5676
+5676,5676,5677
+5677,5677,5678
+5678,5678,5679
+5679,5679,5680
+5680,5680,5681
+5681,5681,5682
+5682,5682,5683
+5683,5683,5684
+5684,5684,5685
+5685,5685,5686
+5686,5686,5687
+5687,5687,5688
+5688,5688,5689
+5689,5689,5690
+5690,5690,5691
+5691,5691,5692
+5692,5692,5693
+5693,5693,5694
+5694,5694,5695
+5695,5695,5696
+5696,5696,5697
+5697,5697,5698
+5698,5698,5699
+5699,5699,5700
+5700,5700,5701
+5701,5701,5702
+5702,5702,5703
+5703,5703,5704
+5704,5704,5705
+5705,5705,5706
+5706,5706,5707
+5707,5707,5708
+5708,5708,5709
+5709,5709,5710
+5710,5710,5711
+5711,5711,5712
+5712,5712,5713
+5713,5713,5714
+5714,5714,5715
+5715,5715,5716
+5716,5716,5717
+5717,5717,5718
+5718,5718,5719
+5719,5719,5720
+5720,5720,5721
+5721,5721,5722
+5722,5722,5723
+5723,5723,5724
+5724,5724,5725
+5725,5725,5726
+5726,5726,5727
+5727,5727,5728
+5728,5728,5729
+5729,5729,5730
+5730,5730,5731
+5731,5731,5732
+5732,5732,5733
+5733,5733,5734
+5734,5734,5735
+5735,5735,5736
+5736,5736,5737
+5737,5737,5738
+5738,5738,5739
+5739,5739,5740
+5740,5740,5741
+5741,5741,5742
+5742,5742,5743
+5743,5743,5744
+5744,5744,5745
+5745,5745,5746
+5746,5746,5747
+5747,5747,5748
+5748,5748,5749
+5749,5749,5750
+5750,5750,5751
+5751,5751,5752
+5752,5752,5753
+5753,5753,5754
+5754,5754,5755
+5755,5755,5756
+5756,5756,5757
+5757,5757,5758
+5758,5758,5759
+5759,5759,5760
+5760,5760,5761
+5761,5761,5762
+5762,5762,5763
+5763,5763,5764
+5764,5764,5765
+5765,5765,5766
+5766,5766,5767
+5767,5767,5768
+5768,5768,5769
+5769,5769,5770
+5770,5770,5771
+5771,5771,5772
+5772,5772,5773
+5773,5773,5774
+5774,5774,5775
+5775,5775,5776
+5776,5776,5777
+5777,5777,5778
+5778,5778,5779
+5779,5779,5780
+5780,5780,5781
+5781,5781,5782
+5782,5782,5783
+5783,5783,5784
+5784,5784,5785
+5785,5785,5786
+5786,5786,5787
+5787,5787,5788
+5788,5788,5789
+5789,5789,5790
+5790,5790,5791
+5791,5791,5792
+5792,5792,5793
+5793,5793,5794
+5794,5794,5795
+5795,5795,5796
+5796,5796,5797
+5797,5797,5798
+5798,5798,5799
+5799,5799,5800
+5800,5800,5801
+5801,5801,5802
+5802,5802,5803
+5803,5803,5804
+5804,5804,5805
+5805,5805,5806
+5806,5806,5807
+5807,5807,5808
+5808,5808,5809
+5809,5809,5810
+5810,5810,5811
+5811,5811,5812
+5812,5812,5813
+5813,5813,5814
+5814,5814,5815
+5815,5815,5816
+5816,5816,5817
+5817,5817,5818
+5818,5818,5819
+5819,5819,5820
+5820,5820,5821
+5821,5821,5822
+5822,5822,5823
+5823,5823,5824
+5824,5824,5825
+5825,5825,5826
+5826,5826,5827
+5827,5827,5828
+5828,5828,5829
+5829,5829,5830
+5830,5830,5831
+5831,5831,5832
+5832,5832,5833
+5833,5833,5834
+5834,5834,5835
+5835,5835,5836
+5836,5836,5837
+5837,5837,5838
+5838,5838,5839
+5839,5839,5840
+5840,5840,5841
+5841,5841,5842
+5842,5842,5843
+5843,5843,5844
+5844,5844,5845
+5845,5845,5846
+5846,5846,5847
+5847,5847,5848
+5848,5848,5849
+5849,5849,5850
+5850,5850,5851
+5851,5851,5852
+5852,5852,5853
+5853,5853,5854
+5854,5854,5855
+5855,5855,5856
+5856,5856,5857
+5857,5857,5858
+5858,5858,5859
+5859,5859,5860
+5860,5860,5861
+5861,5861,5862
+5862,5862,5863
+5863,5863,5864
+5864,5864,5865
+5865,5865,5866
+5866,5866,5867
+5867,5867,5868
+5868,5868,5869
+5869,5869,5870
+5870,5870,5871
+5871,5871,5872
+5872,5872,5873
+5873,5873,5874
+5874,5874,5875
+5875,5875,5876
+5876,5876,5877
+5877,5877,5878
+5878,5878,5879
+5879,5879,5880
+5880,5880,5881
+5881,5881,5882
+5882,5882,5883
+5883,5883,5884
+5884,5884,5885
+5885,5885,5886
+5886,5886,5887
+5887,5887,5888
+5888,5888,5889
+5889,5889,5890
+5890,5890,5891
+5891,5891,5892
+5892,5892,5893
+5893,5893,5894
+5894,5894,5895
+5895,5895,5896
+5896,5896,5897
+5897,5897,5898
+5898,5898,5899
+5899,5899,5900
+5900,5900,5901
+5901,5901,5902
+5902,5902,5903
+5903,5903,5904
+5904,5904,5905
+5905,5905,5906
+5906,5906,5907
+5907,5907,5908
+5908,5908,5909
+5909,5909,5910
+5910,5910,5911
+5911,5911,5912
+5912,5912,5913
+5913,5913,5914
+5914,5914,5915
+5915,5915,5916
+5916,5916,5917
+5917,5917,5918
+5918,5918,5919
+5919,5919,5920
+5920,5920,5921
+5921,5921,5922
+5922,5922,5923
+5923,5923,5924
+5924,5924,5925
+5925,5925,5926
+5926,5926,5927
+5927,5927,5928
+5928,5928,5929
+5929,5929,5930
+5930,5930,5931
+5931,5931,5932
+5932,5932,5933
+5933,5933,5934
+5934,5934,5935
+5935,5935,5936
+5936,5936,5937
+5937,5937,5938
+5938,5938,5939
+5939,5939,5940
+5940,5940,5941
+5941,5941,5942
+5942,5942,5943
+5943,5943,5944
+5944,5944,5945
+5945,5945,5946
+5946,5946,5947
+5947,5947,5948
+5948,5948,5949
+5949,5949,5950
+5950,5950,5951
+5951,5951,5952
+5952,5952,5953
+5953,5953,5954
+5954,5954,5955
+5955,5955,5956
+5956,5956,5957
+5957,5957,5958
+5958,5958,5959
+5959,5959,5960
+5960,5960,5961
+5961,5961,5962
+5962,5962,5963
+5963,5963,5964
+5964,5964,5965
+5965,5965,5966
+5966,5966,5967
+5967,5967,5968
+5968,5968,5969
+5969,5969,5970
+5970,5970,5971
+5971,5971,5972
+5972,5972,5973
+5973,5973,5974
+5974,5974,5975
+5975,5975,5976
+5976,5976,5977
+5977,5977,5978
+5978,5978,5979
+5979,5979,5980
+5980,5980,5981
+5981,5981,5982
+5982,5982,5983
+5983,5983,5984
+5984,5984,5985
+5985,5985,5986
+5986,5986,5987
+5987,5987,5988
+5988,5988,5989
+5989,5989,5990
+5990,5990,5991
+5991,5991,5992
+5992,5992,5993
+5993,5993,5994
+5994,5994,5995
+5995,5995,5996
+5996,5996,5997
+5997,5997,5998
+5998,5998,5999
+5999,5999,6000
+6000,6000,6001
+6001,6001,6002
+6002,6002,6003
+6003,6003,6004
+6004,6004,6005
+6005,6005,6006
+6006,6006,6007
+6007,6007,6008
+6008,6008,6009
+6009,6009,6010
+6010,6010,6011
+6011,6011,6012
+6012,6012,6013
+6013,6013,6014
+6014,6014,6015
+6015,6015,6016
+6016,6016,6017
+6017,6017,6018
+6018,6018,6019
+6019,6019,6020
+6020,6020,6021
+6021,6021,6022
+6022,6022,6023
+6023,6023,6024
+6024,6024,6025
+6025,6025,6026
+6026,6026,6027
+6027,6027,6028
+6028,6028,6029
+6029,6029,6030
+6030,6030,6031
+6031,6031,6032
+6032,6032,6033
+6033,6033,6034
+6034,6034,6035
+6035,6035,6036
+6036,6036,6037
+6037,6037,6038
+6038,6038,6039
+6039,6039,6040
+6040,6040,6041
+6041,6041,6042
+6042,6042,6043
+6043,6043,6044
+6044,6044,6045
+6045,6045,6046
+6046,6046,6047
+6047,6047,6048
+6048,6048,6049
+6049,6049,6050
+6050,6050,6051
+6051,6051,6052
+6052,6052,6053
+6053,6053,6054
+6054,6054,6055
+6055,6055,6056
+6056,6056,6057
+6057,6057,6058
+6058,6058,6059
+6059,6059,6060
+6060,6060,6061
+6061,6061,6062
+6062,6062,6063
+6063,6063,6064
+6064,6064,6065
+6065,6065,6066
+6066,6066,6067
+6067,6067,6068
+6068,6068,6069
+6069,6069,6070
+6070,6070,6071
+6071,6071,6072
+6072,6072,6073
+6073,6073,6074
+6074,6074,6075
+6075,6075,6076
+6076,6076,6077
+6077,6077,6078
+6078,6078,6079
+6079,6079,6080
+6080,6080,6081
+6081,6081,6082
+6082,6082,6083
+6083,6083,6084
+6084,6084,6085
+6085,6085,6086
+6086,6086,6087
+6087,6087,6088
+6088,6088,6089
+6089,6089,6090
+6090,6090,6091
+6091,6091,6092
+6092,6092,6093
+6093,6093,6094
+6094,6094,6095
+6095,6095,6096
+6096,6096,6097
+6097,6097,6098
+6098,6098,6099
+6099,6099,6100
+6100,6100,6101
+6101,6101,6102
+6102,6102,6103
+6103,6103,6104
+6104,6104,6105
+6105,6105,6106
+6106,6106,6107
+6107,6107,6108
+6108,6108,6109
+6109,6109,6110
+6110,6110,6111
+6111,6111,6112
+6112,6112,6113
+6113,6113,6114
+6114,6114,6115
+6115,6115,6116
+6116,6116,6117
+6117,6117,6118
+6118,6118,6119
+6119,6119,6120
+6120,6120,6121
+6121,6121,6122
+6122,6122,6123
+6123,6123,6124
+6124,6124,6125
+6125,6125,6126
+6126,6126,6127
+6127,6127,6128
+6128,6128,6129
+6129,6129,6130
+6130,6130,6131
+6131,6131,6132
+6132,6132,6133
+6133,6133,6134
+6134,6134,6135
+6135,6135,6136
+6136,6136,6137
+6137,6137,6138
+6138,6138,6139
+6139,6139,6140
+6140,6140,6141
+6141,6141,6142
+6142,6142,6143
+6143,6143,6144
+6144,6144,6145
+6145,6145,6146
+6146,6146,6147
+6147,6147,6148
+6148,6148,6149
+6149,6149,6150
+6150,6150,6151
+6151,6151,6152
+6152,6152,6153
+6153,6153,6154
+6154,6154,6155
+6155,6155,6156
+6156,6156,6157
+6157,6157,6158
+6158,6158,6159
+6159,6159,6160
+6160,6160,6161
+6161,6161,6162
+6162,6162,6163
+6163,6163,6164
+6164,6164,6165
+6165,6165,6166
+6166,6166,6167
+6167,6167,6168
+6168,6168,6169
+6169,6169,6170
+6170,6170,6171
+6171,6171,6172
+6172,6172,6173
+6173,6173,6174
+6174,6174,6175
+6175,6175,6176
+6176,6176,6177
+6177,6177,6178
+6178,6178,6179
+6179,6179,6180
+6180,6180,6181
+6181,6181,6182
+6182,6182,6183
+6183,6183,6184
+6184,6184,6185
+6185,6185,6186
+6186,6186,6187
+6187,6187,6188
+6188,6188,6189
+6189,6189,6190
+6190,6190,6191
+6191,6191,6192
+6192,6192,6193
+6193,6193,6194
+6194,6194,6195
+6195,6195,6196
+6196,6196,6197
+6197,6197,6198
+6198,6198,6199
+6199,6199,6200
+6200,6200,6201
+6201,6201,6202
+6202,6202,6203
+6203,6203,6204
+6204,6204,6205
+6205,6205,6206
+6206,6206,6207
+6207,6207,6208
+6208,6208,6209
+6209,6209,6210
+6210,6210,6211
+6211,6211,6212
+6212,6212,6213
+6213,6213,6214
+6214,6214,6215
+6215,6215,6216
+6216,6216,6217
+6217,6217,6218
+6218,6218,6219
+6219,6219,6220
+6220,6220,6221
+6221,6221,6222
+6222,6222,6223
+6223,6223,6224
+6224,6224,6225
+6225,6225,6226
+6226,6226,6227
+6227,6227,6228
+6228,6228,6229
+6229,6229,6230
+6230,6230,6231
+6231,6231,6232
+6232,6232,6233
+6233,6233,6234
+6234,6234,6235
+6235,6235,6236
+6236,6236,6237
+6237,6237,6238
+6238,6238,6239
+6239,6239,6240
+6240,6240,6241
+6241,6241,6242
+6242,6242,6243
+6243,6243,6244
+6244,6244,6245
+6245,6245,6246
+6246,6246,6247
+6247,6247,6248
+6248,6248,6249
+6249,6249,6250
+6250,6250,6251
+6251,6251,6252
+6252,6252,6253
+6253,6253,6254
+6254,6254,6255
+6255,6255,6256
+6256,6256,6257
+6257,6257,6258
+6258,6258,6259
+6259,6259,6260
+6260,6260,6261
+6261,6261,6262
+6262,6262,6263
+6263,6263,6264
+6264,6264,6265
+6265,6265,6266
+6266,6266,6267
+6267,6267,6268
+6268,6268,6269
+6269,6269,6270
+6270,6270,6271
+6271,6271,6272
+6272,6272,6273
+6273,6273,6274
+6274,6274,6275
+6275,6275,6276
+6276,6276,6277
+6277,6277,6278
+6278,6278,6279
+6279,6279,6280
+6280,6280,6281
+6281,6281,6282
+6282,6282,6283
+6283,6283,6284
+6284,6284,6285
+6285,6285,6286
+6286,6286,6287
+6287,6287,6288
+6288,6288,6289
+6289,6289,6290
+6290,6290,6291
+6291,6291,6292
+6292,6292,6293
+6293,6293,6294
+6294,6294,6295
+6295,6295,6296
+6296,6296,6297
+6297,6297,6298
+6298,6298,6299
+6299,6299,6300
+6300,6300,6301
+6301,6301,6302
+6302,6302,6303
+6303,6303,6304
+6304,6304,6305
+6305,6305,6306
+6306,6306,6307
+6307,6307,6308
+6308,6308,6309
+6309,6309,6310
+6310,6310,6311
+6311,6311,6312
+6312,6312,6313
+6313,6313,6314
+6314,6314,6315
+6315,6315,6316
+6316,6316,6317
+6317,6317,6318
+6318,6318,6319
+6319,6319,6320
+6320,6320,6321
+6321,6321,6322
+6322,6322,6323
+6323,6323,6324
+6324,6324,6325
+6325,6325,6326
+6326,6326,6327
+6327,6327,6328
+6328,6328,6329
+6329,6329,6330
+6330,6330,6331
+6331,6331,6332
+6332,6332,6333
+6333,6333,6334
+6334,6334,6335
+6335,6335,6336
+6336,6336,6337
+6337,6337,6338
+6338,6338,6339
+6339,6339,6340
+6340,6340,6341
+6341,6341,6342
+6342,6342,6343
+6343,6343,6344
+6344,6344,6345
+6345,6345,6346
+6346,6346,6347
+6347,6347,6348
+6348,6348,6349
+6349,6349,6350
+6350,6350,6351
+6351,6351,6352
+6352,6352,6353
+6353,6353,6354
+6354,6354,6355
+6355,6355,6356
+6356,6356,6357
+6357,6357,6358
+6358,6358,6359
+6359,6359,6360
+6360,6360,6361
+6361,6361,6362
+6362,6362,6363
+6363,6363,6364
+6364,6364,6365
+6365,6365,6366
+6366,6366,6367
+6367,6367,6368
+6368,6368,6369
+6369,6369,6370
+6370,6370,6371
+6371,6371,6372
+6372,6372,6373
+6373,6373,6374
+6374,6374,6375
+6375,6375,6376
+6376,6376,6377
+6377,6377,6378
+6378,6378,6379
+6379,6379,6380
+6380,6380,6381
+6381,6381,6382
+6382,6382,6383
+6383,6383,6384
+6384,6384,6385
+6385,6385,6386
+6386,6386,6387
+6387,6387,6388
+6388,6388,6389
+6389,6389,6390
+6390,6390,6391
+6391,6391,6392
+6392,6392,6393
+6393,6393,6394
+6394,6394,6395
+6395,6395,6396
+6396,6396,6397
+6397,6397,6398
+6398,6398,6399
+6399,6399,6400
+6400,6400,6401
+6401,6401,6402
+6402,6402,6403
+6403,6403,6404
+6404,6404,6405
+6405,6405,6406
+6406,6406,6407
+6407,6407,6408
+6408,6408,6409
+6409,6409,6410
+6410,6410,6411
+6411,6411,6412
+6412,6412,6413
+6413,6413,6414
+6414,6414,6415
+6415,6415,6416
+6416,6416,6417
+6417,6417,6418
+6418,6418,6419
+6419,6419,6420
+6420,6420,6421
+6421,6421,6422
+6422,6422,6423
+6423,6423,6424
+6424,6424,6425
+6425,6425,6426
+6426,6426,6427
+6427,6427,6428
+6428,6428,6429
+6429,6429,6430
+6430,6430,6431
+6431,6431,6432
+6432,6432,6433
+6433,6433,6434
+6434,6434,6435
+6435,6435,6436
+6436,6436,6437
+6437,6437,6438
+6438,6438,6439
+6439,6439,6440
+6440,6440,6441
+6441,6441,6442
+6442,6442,6443
+6443,6443,6444
+6444,6444,6445
+6445,6445,6446
+6446,6446,6447
+6447,6447,6448
+6448,6448,6449
+6449,6449,6450
+6450,6450,6451
+6451,6451,6452
+6452,6452,6453
+6453,6453,6454
+6454,6454,6455
+6455,6455,6456
+6456,6456,6457
+6457,6457,6458
+6458,6458,6459
+6459,6459,6460
+6460,6460,6461
+6461,6461,6462
+6462,6462,6463
+6463,6463,6464
+6464,6464,6465
+6465,6465,6466
+6466,6466,6467
+6467,6467,6468
+6468,6468,6469
+6469,6469,6470
+6470,6470,6471
+6471,6471,6472
+6472,6472,6473
+6473,6473,6474
+6474,6474,6475
+6475,6475,6476
+6476,6476,6477
+6477,6477,6478
+6478,6478,6479
+6479,6479,6480
+6480,6480,6481
+6481,6481,6482
+6482,6482,6483
+6483,6483,6484
+6484,6484,6485
+6485,6485,6486
+6486,6486,6487
+6487,6487,6488
+6488,6488,6489
+6489,6489,6490
+6490,6490,6491
+6491,6491,6492
+6492,6492,6493
+6493,6493,6494
+6494,6494,6495
+6495,6495,6496
+6496,6496,6497
+6497,6497,6498
+6498,6498,6499
+6499,6499,6500
+6500,6500,6501
+6501,6501,6502
+6502,6502,6503
+6503,6503,6504
+6504,6504,6505
+6505,6505,6506
+6506,6506,6507
+6507,6507,6508
+6508,6508,6509
+6509,6509,6510
+6510,6510,6511
+6511,6511,6512
+6512,6512,6513
+6513,6513,6514
+6514,6514,6515
+6515,6515,6516
+6516,6516,6517
+6517,6517,6518
+6518,6518,6519
+6519,6519,6520
+6520,6520,6521
+6521,6521,6522
+6522,6522,6523
+6523,6523,6524
+6524,6524,6525
+6525,6525,6526
+6526,6526,6527
+6527,6527,6528
+6528,6528,6529
+6529,6529,6530
+6530,6530,6531
+6531,6531,6532
+6532,6532,6533
+6533,6533,6534
+6534,6534,6535
+6535,6535,6536
+6536,6536,6537
+6537,6537,6538
+6538,6538,6539
+6539,6539,6540
+6540,6540,6541
+6541,6541,6542
+6542,6542,6543
+6543,6543,6544
+6544,6544,6545
+6545,6545,6546
+6546,6546,6547
+6547,6547,6548
+6548,6548,6549
+6549,6549,6550
+6550,6550,6551
+6551,6551,6552
+6552,6552,6553
+6553,6553,6554
+6554,6554,6555
+6555,6555,6556
+6556,6556,6557
+6557,6557,6558
+6558,6558,6559
+6559,6559,6560
+6560,6560,6561
+6561,6561,6562
+6562,6562,6563
+6563,6563,6564
+6564,6564,6565
+6565,6565,6566
+6566,6566,6567
+6567,6567,6568
+6568,6568,6569
+6569,6569,6570
+6570,6570,6571
+6571,6571,6572
+6572,6572,6573
+6573,6573,6574
+6574,6574,6575
+6575,6575,6576
+6576,6576,6577
+6577,6577,6578
+6578,6578,6579
+6579,6579,6580
+6580,6580,6581
+6581,6581,6582
+6582,6582,6583
+6583,6583,6584
+6584,6584,6585
+6585,6585,6586
+6586,6586,6587
+6587,6587,6588
+6588,6588,6589
+6589,6589,6590
+6590,6590,6591
+6591,6591,6592
+6592,6592,6593
+6593,6593,6594
+6594,6594,6595
+6595,6595,6596
+6596,6596,6597
+6597,6597,6598
+6598,6598,6599
+6599,6599,6600
+6600,6600,6601
+6601,6601,6602
+6602,6602,6603
+6603,6603,6604
+6604,6604,6605
+6605,6605,6606
+6606,6606,6607
+6607,6607,6608
+6608,6608,6609
+6609,6609,6610
+6610,6610,6611
+6611,6611,6612
+6612,6612,6613
+6613,6613,6614
+6614,6614,6615
+6615,6615,6616
+6616,6616,6617
+6617,6617,6618
+6618,6618,6619
+6619,6619,6620
+6620,6620,6621
+6621,6621,6622
+6622,6622,6623
+6623,6623,6624
+6624,6624,6625
+6625,6625,6626
+6626,6626,6627
+6627,6627,6628
+6628,6628,6629
+6629,6629,6630
+6630,6630,6631
+6631,6631,6632
+6632,6632,6633
+6633,6633,6634
+6634,6634,6635
+6635,6635,6636
+6636,6636,6637
+6637,6637,6638
+6638,6638,6639
+6639,6639,6640
+6640,6640,6641
+6641,6641,6642
+6642,6642,6643
+6643,6643,6644
+6644,6644,6645
+6645,6645,6646
+6646,6646,6647
+6647,6647,6648
+6648,6648,6649
+6649,6649,6650
+6650,6650,6651
+6651,6651,6652
+6652,6652,6653
+6653,6653,6654
+6654,6654,6655
+6655,6655,6656
+6656,6656,6657
+6657,6657,6658
+6658,6658,6659
+6659,6659,6660
+6660,6660,6661
+6661,6661,6662
+6662,6662,6663
+6663,6663,6664
+6664,6664,6665
+6665,6665,6666
+6666,6666,6667
+6667,6667,6668
+6668,6668,6669
+6669,6669,6670
+6670,6670,6671
+6671,6671,6672
+6672,6672,6673
+6673,6673,6674
+6674,6674,6675
+6675,6675,6676
+6676,6676,6677
+6677,6677,6678
+6678,6678,6679
+6679,6679,6680
+6680,6680,6681
+6681,6681,6682
+6682,6682,6683
+6683,6683,6684
+6684,6684,6685
+6685,6685,6686
+6686,6686,6687
+6687,6687,6688
+6688,6688,6689
+6689,6689,6690
+6690,6690,6691
+6691,6691,6692
+6692,6692,6693
+6693,6693,6694
+6694,6694,6695
+6695,6695,6696
+6696,6696,6697
+6697,6697,6698
+6698,6698,6699
+6699,6699,6700
+6700,6700,6701
+6701,6701,6702
+6702,6702,6703
+6703,6703,6704
+6704,6704,6705
+6705,6705,6706
+6706,6706,6707
+6707,6707,6708
+6708,6708,6709
+6709,6709,6710
+6710,6710,6711
+6711,6711,6712
+6712,6712,6713
+6713,6713,6714
+6714,6714,6715
+6715,6715,6716
+6716,6716,6717
+6717,6717,6718
+6718,6718,6719
+6719,6719,6720
+6720,6720,6721
+6721,6721,6722
+6722,6722,6723
+6723,6723,6724
+6724,6724,6725
+6725,6725,6726
+6726,6726,6727
+6727,6727,6728
+6728,6728,6729
+6729,6729,6730
+6730,6730,6731
+6731,6731,6732
+6732,6732,6733
+6733,6733,6734
+6734,6734,6735
+6735,6735,6736
+6736,6736,6737
+6737,6737,6738
+6738,6738,6739
+6739,6739,6740
+6740,6740,6741
+6741,6741,6742
+6742,6742,6743
+6743,6743,6744
+6744,6744,6745
+6745,6745,6746
+6746,6746,6747
+6747,6747,6748
+6748,6748,6749
+6749,6749,6750
+6750,6750,6751
+6751,6751,6752
+6752,6752,6753
+6753,6753,6754
+6754,6754,6755
+6755,6755,6756
+6756,6756,6757
+6757,6757,6758
+6758,6758,6759
+6759,6759,6760
+6760,6760,6761
+6761,6761,6762
+6762,6762,6763
+6763,6763,6764
+6764,6764,6765
+6765,6765,6766
+6766,6766,6767
+6767,6767,6768
+6768,6768,6769
+6769,6769,6770
+6770,6770,6771
+6771,6771,6772
+6772,6772,6773
+6773,6773,6774
+6774,6774,6775
+6775,6775,6776
+6776,6776,6777
+6777,6777,6778
+6778,6778,6779
+6779,6779,6780
+6780,6780,6781
+6781,6781,6782
+6782,6782,6783
+6783,6783,6784
+6784,6784,6785
+6785,6785,6786
+6786,6786,6787
+6787,6787,6788
+6788,6788,6789
+6789,6789,6790
+6790,6790,6791
+6791,6791,6792
+6792,6792,6793
+6793,6793,6794
+6794,6794,6795
+6795,6795,6796
+6796,6796,6797
+6797,6797,6798
+6798,6798,6799
+6799,6799,6800
+6800,6800,6801
+6801,6801,6802
+6802,6802,6803
+6803,6803,6804
+6804,6804,6805
+6805,6805,6806
+6806,6806,6807
+6807,6807,6808
+6808,6808,6809
+6809,6809,6810
+6810,6810,6811
+6811,6811,6812
+6812,6812,6813
+6813,6813,6814
+6814,6814,6815
+6815,6815,6816
+6816,6816,6817
+6817,6817,6818
+6818,6818,6819
+6819,6819,6820
+6820,6820,6821
+6821,6821,6822
+6822,6822,6823
+6823,6823,6824
+6824,6824,6825
+6825,6825,6826
+6826,6826,6827
+6827,6827,6828
+6828,6828,6829
+6829,6829,6830
+6830,6830,6831
+6831,6831,6832
+6832,6832,6833
+6833,6833,6834
+6834,6834,6835
+6835,6835,6836
+6836,6836,6837
+6837,6837,6838
+6838,6838,6839
+6839,6839,6840
+6840,6840,6841
+6841,6841,6842
+6842,6842,6843
+6843,6843,6844
+6844,6844,6845
+6845,6845,6846
+6846,6846,6847
+6847,6847,6848
+6848,6848,6849
+6849,6849,6850
+6850,6850,6851
+6851,6851,6852
+6852,6852,6853
+6853,6853,6854
+6854,6854,6855
+6855,6855,6856
+6856,6856,6857
+6857,6857,6858
+6858,6858,6859
+6859,6859,6860
+6860,6860,6861
+6861,6861,6862
+6862,6862,6863
+6863,6863,6864
+6864,6864,6865
+6865,6865,6866
+6866,6866,6867
+6867,6867,6868
+6868,6868,6869
+6869,6869,6870
+6870,6870,6871
+6871,6871,6872
+6872,6872,6873
+6873,6873,6874
+6874,6874,6875
+6875,6875,6876
+6876,6876,6877
+6877,6877,6878
+6878,6878,6879
+6879,6879,6880
+6880,6880,6881
+6881,6881,6882
+6882,6882,6883
+6883,6883,6884
+6884,6884,6885
+6885,6885,6886
+6886,6886,6887
+6887,6887,6888
+6888,6888,6889
+6889,6889,6890
+6890,6890,6891
+6891,6891,6892
+6892,6892,6893
+6893,6893,6894
+6894,6894,6895
+6895,6895,6896
+6896,6896,6897
+6897,6897,6898
+6898,6898,6899
+6899,6899,6900
+6900,6900,6901
+6901,6901,6902
+6902,6902,6903
+6903,6903,6904
+6904,6904,6905
+6905,6905,6906
+6906,6906,6907
+6907,6907,6908
+6908,6908,6909
+6909,6909,6910
+6910,6910,6911
+6911,6911,6912
+6912,6912,6913
+6913,6913,6914
+6914,6914,6915
+6915,6915,6916
+6916,6916,6917
+6917,6917,6918
+6918,6918,6919
+6919,6919,6920
+6920,6920,6921
+6921,6921,6922
+6922,6922,6923
+6923,6923,6924
+6924,6924,6925
+6925,6925,6926
+6926,6926,6927
+6927,6927,6928
+6928,6928,6929
+6929,6929,6930
+6930,6930,6931
+6931,6931,6932
+6932,6932,6933
+6933,6933,6934
+6934,6934,6935
+6935,6935,6936
+6936,6936,6937
+6937,6937,6938
+6938,6938,6939
+6939,6939,6940
+6940,6940,6941
+6941,6941,6942
+6942,6942,6943
+6943,6943,6944
+6944,6944,6945
+6945,6945,6946
+6946,6946,6947
+6947,6947,6948
+6948,6948,6949
+6949,6949,6950
+6950,6950,6951
+6951,6951,6952
+6952,6952,6953
+6953,6953,6954
+6954,6954,6955
+6955,6955,6956
+6956,6956,6957
+6957,6957,6958
+6958,6958,6959
+6959,6959,6960
+6960,6960,6961
+6961,6961,6962
+6962,6962,6963
+6963,6963,6964
+6964,6964,6965
+6965,6965,6966
+6966,6966,6967
+6967,6967,6968
+6968,6968,6969
+6969,6969,6970
+6970,6970,6971
+6971,6971,6972
+6972,6972,6973
+6973,6973,6974
+6974,6974,6975
+6975,6975,6976
+6976,6976,6977
+6977,6977,6978
+6978,6978,6979
+6979,6979,6980
+6980,6980,6981
+6981,6981,6982
+6982,6982,6983
+6983,6983,6984
+6984,6984,6985
+6985,6985,6986
+6986,6986,6987
+6987,6987,6988
+6988,6988,6989
+6989,6989,6990
+6990,6990,6991
+6991,6991,6992
+6992,6992,6993
+6993,6993,6994
+6994,6994,6995
+6995,6995,6996
+6996,6996,6997
+6997,6997,6998
+6998,6998,6999
+6999,6999,7000
+7000,7000,7001
+7001,7001,7002
+7002,7002,7003
+7003,7003,7004
+7004,7004,7005
+7005,7005,7006
+7006,7006,7007
+7007,7007,7008
+7008,7008,7009
+7009,7009,7010
+7010,7010,7011
+7011,7011,7012
+7012,7012,7013
+7013,7013,7014
+7014,7014,7015
+7015,7015,7016
+7016,7016,7017
+7017,7017,7018
+7018,7018,7019
+7019,7019,7020
+7020,7020,7021
+7021,7021,7022
+7022,7022,7023
+7023,7023,7024
+7024,7024,7025
+7025,7025,7026
+7026,7026,7027
+7027,7027,7028
+7028,7028,7029
+7029,7029,7030
+7030,7030,7031
+7031,7031,7032
+7032,7032,7033
+7033,7033,7034
+7034,7034,7035
+7035,7035,7036
+7036,7036,7037
+7037,7037,7038
+7038,7038,7039
+7039,7039,7040
+7040,7040,7041
+7041,7041,7042
+7042,7042,7043
+7043,7043,7044
+7044,7044,7045
+7045,7045,7046
+7046,7046,7047
+7047,7047,7048
+7048,7048,7049
+7049,7049,7050
+7050,7050,7051
+7051,7051,7052
+7052,7052,7053
+7053,7053,7054
+7054,7054,7055
+7055,7055,7056
+7056,7056,7057
+7057,7057,7058
+7058,7058,7059
+7059,7059,7060
+7060,7060,7061
+7061,7061,7062
+7062,7062,7063
+7063,7063,7064
+7064,7064,7065
+7065,7065,7066
+7066,7066,7067
+7067,7067,7068
+7068,7068,7069
+7069,7069,7070
+7070,7070,7071
+7071,7071,7072
+7072,7072,7073
+7073,7073,7074
+7074,7074,7075
+7075,7075,7076
+7076,7076,7077
+7077,7077,7078
+7078,7078,7079
+7079,7079,7080
+7080,7080,7081
+7081,7081,7082
+7082,7082,7083
+7083,7083,7084
+7084,7084,7085
+7085,7085,7086
+7086,7086,7087
+7087,7087,7088
+7088,7088,7089
+7089,7089,7090
+7090,7090,7091
+7091,7091,7092
+7092,7092,7093
+7093,7093,7094
+7094,7094,7095
+7095,7095,7096
+7096,7096,7097
+7097,7097,7098
+7098,7098,7099
+7099,7099,7100
+7100,7100,7101
+7101,7101,7102
+7102,7102,7103
+7103,7103,7104
+7104,7104,7105
+7105,7105,7106
+7106,7106,7107
+7107,7107,7108
+7108,7108,7109
+7109,7109,7110
+7110,7110,7111
+7111,7111,7112
+7112,7112,7113
+7113,7113,7114
+7114,7114,7115
+7115,7115,7116
+7116,7116,7117
+7117,7117,7118
+7118,7118,7119
+7119,7119,7120
+7120,7120,7121
+7121,7121,7122
+7122,7122,7123
+7123,7123,7124
+7124,7124,7125
+7125,7125,7126
+7126,7126,7127
+7127,7127,7128
+7128,7128,7129
+7129,7129,7130
+7130,7130,7131
+7131,7131,7132
+7132,7132,7133
+7133,7133,7134
+7134,7134,7135
+7135,7135,7136
+7136,7136,7137
+7137,7137,7138
+7138,7138,7139
+7139,7139,7140
+7140,7140,7141
+7141,7141,7142
+7142,7142,7143
+7143,7143,7144
+7144,7144,7145
+7145,7145,7146
+7146,7146,7147
+7147,7147,7148
+7148,7148,7149
+7149,7149,7150
+7150,7150,7151
+7151,7151,7152
+7152,7152,7153
+7153,7153,7154
+7154,7154,7155
+7155,7155,7156
+7156,7156,7157
+7157,7157,7158
+7158,7158,7159
+7159,7159,7160
+7160,7160,7161
+7161,7161,7162
+7162,7162,7163
+7163,7163,7164
+7164,7164,7165
+7165,7165,7166
+7166,7166,7167
+7167,7167,7168
+7168,7168,7169
+7169,7169,7170
+7170,7170,7171
+7171,7171,7172
+7172,7172,7173
+7173,7173,7174
+7174,7174,7175
+7175,7175,7176
+7176,7176,7177
+7177,7177,7178
+7178,7178,7179
+7179,7179,7180
+7180,7180,7181
+7181,7181,7182
+7182,7182,7183
+7183,7183,7184
+7184,7184,7185
+7185,7185,7186
+7186,7186,7187
+7187,7187,7188
+7188,7188,7189
+7189,7189,7190
+7190,7190,7191
+7191,7191,7192
+7192,7192,7193
+7193,7193,7194
+7194,7194,7195
+7195,7195,7196
+7196,7196,7197
+7197,7197,7198
+7198,7198,7199
+7199,7199,7200
+7200,7200,7201
+7201,7201,7202
+7202,7202,7203
+7203,7203,7204
+7204,7204,7205
+7205,7205,7206
+7206,7206,7207
+7207,7207,7208
+7208,7208,7209
+7209,7209,7210
+7210,7210,7211
+7211,7211,7212
+7212,7212,7213
+7213,7213,7214
+7214,7214,7215
+7215,7215,7216
+7216,7216,7217
+7217,7217,7218
+7218,7218,7219
+7219,7219,7220
+7220,7220,7221
+7221,7221,7222
+7222,7222,7223
+7223,7223,7224
+7224,7224,7225
+7225,7225,7226
+7226,7226,7227
+7227,7227,7228
+7228,7228,7229
+7229,7229,7230
+7230,7230,7231
+7231,7231,7232
+7232,7232,7233
+7233,7233,7234
+7234,7234,7235
+7235,7235,7236
+7236,7236,7237
+7237,7237,7238
+7238,7238,7239
+7239,7239,7240
+7240,7240,7241
+7241,7241,7242
+7242,7242,7243
+7243,7243,7244
+7244,7244,7245
+7245,7245,7246
+7246,7246,7247
+7247,7247,7248
+7248,7248,7249
+7249,7249,7250
+7250,7250,7251
+7251,7251,7252
+7252,7252,7253
+7253,7253,7254
+7254,7254,7255
+7255,7255,7256
+7256,7256,7257
+7257,7257,7258
+7258,7258,7259
+7259,7259,7260
+7260,7260,7261
+7261,7261,7262
+7262,7262,7263
+7263,7263,7264
+7264,7264,7265
+7265,7265,7266
+7266,7266,7267
+7267,7267,7268
+7268,7268,7269
+7269,7269,7270
+7270,7270,7271
+7271,7271,7272
+7272,7272,7273
+7273,7273,7274
+7274,7274,7275
+7275,7275,7276
+7276,7276,7277
+7277,7277,7278
+7278,7278,7279
+7279,7279,7280
+7280,7280,7281
+7281,7281,7282
+7282,7282,7283
+7283,7283,7284
+7284,7284,7285
+7285,7285,7286
+7286,7286,7287
+7287,7287,7288
+7288,7288,7289
+7289,7289,7290
+7290,7290,7291
+7291,7291,7292
+7292,7292,7293
+7293,7293,7294
+7294,7294,7295
+7295,7295,7296
+7296,7296,7297
+7297,7297,7298
+7298,7298,7299
+7299,7299,7300
+7300,7300,7301
+7301,7301,7302
+7302,7302,7303
+7303,7303,7304
+7304,7304,7305
+7305,7305,7306
+7306,7306,7307
+7307,7307,7308
+7308,7308,7309
+7309,7309,7310
+7310,7310,7311
+7311,7311,7312
+7312,7312,7313
+7313,7313,7314
+7314,7314,7315
+7315,7315,7316
+7316,7316,7317
+7317,7317,7318
+7318,7318,7319
+7319,7319,7320
+7320,7320,7321
+7321,7321,7322
+7322,7322,7323
+7323,7323,7324
+7324,7324,7325
+7325,7325,7326
+7326,7326,7327
+7327,7327,7328
+7328,7328,7329
+7329,7329,7330
+7330,7330,7331
+7331,7331,7332
+7332,7332,7333
+7333,7333,7334
+7334,7334,7335
+7335,7335,7336
+7336,7336,7337
+7337,7337,7338
+7338,7338,7339
+7339,7339,7340
+7340,7340,7341
+7341,7341,7342
+7342,7342,7343
+7343,7343,7344
+7344,7344,7345
+7345,7345,7346
+7346,7346,7347
+7347,7347,7348
+7348,7348,7349
+7349,7349,7350
+7350,7350,7351
+7351,7351,7352
+7352,7352,7353
+7353,7353,7354
+7354,7354,7355
+7355,7355,7356
+7356,7356,7357
+7357,7357,7358
+7358,7358,7359
+7359,7359,7360
+7360,7360,7361
+7361,7361,7362
+7362,7362,7363
+7363,7363,7364
+7364,7364,7365
+7365,7365,7366
+7366,7366,7367
+7367,7367,7368
+7368,7368,7369
+7369,7369,7370
+7370,7370,7371
+7371,7371,7372
+7372,7372,7373
+7373,7373,7374
+7374,7374,7375
+7375,7375,7376
+7376,7376,7377
+7377,7377,7378
+7378,7378,7379
+7379,7379,7380
+7380,7380,7381
+7381,7381,7382
+7382,7382,7383
+7383,7383,7384
+7384,7384,7385
+7385,7385,7386
+7386,7386,7387
+7387,7387,7388
+7388,7388,7389
+7389,7389,7390
+7390,7390,7391
+7391,7391,7392
+7392,7392,7393
+7393,7393,7394
+7394,7394,7395
+7395,7395,7396
+7396,7396,7397
+7397,7397,7398
+7398,7398,7399
+7399,7399,7400
+7400,7400,7401
+7401,7401,7402
+7402,7402,7403
+7403,7403,7404
+7404,7404,7405
... 23079 lines suppressed ...
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org