From 55107b6f7438f59789752e32f0327c0b6ba739ec Mon Sep 17 00:00:00 2001
From: duanmeng <macduan@tencent.com>
Date: Tue, 20 Aug 2024 23:47:26 -0700
Subject: [PATCH 01/24] Add Query Trace Writers and Readers (#10774)

Summary:
Add a query tracer to log the input data, and metadata (including query configurations,
connector properties, and query plans). This logged data and metadata can be used to
replay the operations of a specific operator or pipeline.

Part of https://github.com/facebookincubator/velox/issues/9668

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10774

Reviewed By: Yuhta

Differential Revision: D61514971

Pulled By: xiaoxmeng

fbshipit-source-id: 9a0b901ee1475a6c35169fe77eb19e797e31e210
---
 velox/core/QueryConfig.cpp               |   5 +
 velox/core/QueryConfig.h                 |   2 +
 velox/core/QueryCtx.h                    |   5 +
 velox/exec/CMakeLists.txt                |   4 +-
 velox/exec/trace/CMakeLists.txt          |  44 +++++
 velox/exec/trace/QueryDataReader.cpp     |  66 ++++++++
 velox/exec/trace/QueryDataReader.h       |  51 ++++++
 velox/exec/trace/QueryDataWriter.cpp     |  78 +++++++++
 velox/exec/trace/QueryDataWriter.h       |  60 +++++++
 velox/exec/trace/QueryMetadataReader.cpp |  74 ++++++++
 velox/exec/trace/QueryMetadataReader.h   |  42 +++++
 velox/exec/trace/QueryMetadataWriter.cpp |  75 +++++++++
 velox/exec/trace/QueryMetadataWriter.h   |  40 +++++
 velox/exec/trace/QueryTraceConfig.cpp    |  27 +++
 velox/exec/trace/QueryTraceConfig.h      |  35 ++++
 velox/exec/trace/QueryTraceTraits.h      |  34 ++++
 velox/exec/trace/test/CMakeLists.txt     |  31 ++++
 velox/exec/trace/test/QueryTraceTest.cpp | 205 +++++++++++++++++++++++
 18 files changed, 877 insertions(+), 1 deletion(-)
 create mode 100644 velox/exec/trace/CMakeLists.txt
 create mode 100644 velox/exec/trace/QueryDataReader.cpp
 create mode 100644 velox/exec/trace/QueryDataReader.h
 create mode 100644 velox/exec/trace/QueryDataWriter.cpp
 create mode 100644 velox/exec/trace/QueryDataWriter.h
 create mode 100644 velox/exec/trace/QueryMetadataReader.cpp
 create mode 100644 velox/exec/trace/QueryMetadataReader.h
 create mode 100644 velox/exec/trace/QueryMetadataWriter.cpp
 create mode 100644 velox/exec/trace/QueryMetadataWriter.h
 create mode 100644 velox/exec/trace/QueryTraceConfig.cpp
 create mode 100644 velox/exec/trace/QueryTraceConfig.h
 create mode 100644 velox/exec/trace/QueryTraceTraits.h
 create mode 100644 velox/exec/trace/test/CMakeLists.txt
 create mode 100644 velox/exec/trace/test/QueryTraceTest.cpp

diff --git a/velox/core/QueryConfig.cpp b/velox/core/QueryConfig.cpp
index cc9b57b23d6aa..3d5b25ff94878 100644
--- a/velox/core/QueryConfig.cpp
+++ b/velox/core/QueryConfig.cpp
@@ -53,4 +53,9 @@ void QueryConfig::testingOverrideConfigUnsafe(
   config_ = std::make_unique<config::ConfigBase>(std::move(values));
 }
 
+std::unordered_map<std::string, std::string> QueryConfig::rawConfigsCopy()
+    const {
+  return config_->rawConfigsCopy();
+}
+
 } // namespace facebook::velox::core
diff --git a/velox/core/QueryConfig.h b/velox/core/QueryConfig.h
index 93984749a4e3a..78f51375fa45a 100644
--- a/velox/core/QueryConfig.h
+++ b/velox/core/QueryConfig.h
@@ -725,6 +725,8 @@ class QueryConfig {
   void testingOverrideConfigUnsafe(
       std::unordered_map<std::string, std::string>&& values);
 
+  std::unordered_map<std::string, std::string> rawConfigsCopy() const;
+
  private:
   void validateConfig();
 
diff --git a/velox/core/QueryCtx.h b/velox/core/QueryCtx.h
index bd890a899861d..7df296f1ff553 100644
--- a/velox/core/QueryCtx.h
+++ b/velox/core/QueryCtx.h
@@ -85,6 +85,11 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
     return it->second.get();
   }
 
+  const std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>&
+  connectorSessionProperties() const {
+    return connectorSessionProperties_;
+  }
+
   /// Overrides the previous configuration. Note that this function is NOT
   /// thread-safe and should probably only be used in tests.
   void testingOverrideConfigUnsafe(
diff --git a/velox/exec/CMakeLists.txt b/velox/exec/CMakeLists.txt
index 4bcc613213814..c68a9af02ea59 100644
--- a/velox/exec/CMakeLists.txt
+++ b/velox/exec/CMakeLists.txt
@@ -98,7 +98,8 @@ velox_link_libraries(
   velox_common_base
   velox_test_util
   velox_arrow_bridge
-  velox_common_compression)
+  velox_common_compression
+  velox_query_trace_exec)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(fuzzer)
@@ -112,3 +113,4 @@ if(${VELOX_ENABLE_BENCHMARKS})
 endif()
 
 add_subdirectory(prefixsort)
+add_subdirectory(trace)
diff --git a/velox/exec/trace/CMakeLists.txt b/velox/exec/trace/CMakeLists.txt
new file mode 100644
index 0000000000000..532f3ed27f328
--- /dev/null
+++ b/velox/exec/trace/CMakeLists.txt
@@ -0,0 +1,44 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(velox_query_trace_exec QueryMetadataWriter.cpp QueryTraceConfig.cpp
+                                   QueryDataWriter.cpp)
+
+target_link_libraries(
+  velox_query_trace_exec
+  PRIVATE
+    velox_common_io
+    velox_file
+    velox_core
+    velox_vector
+    velox_connector
+    velox_common_base
+    velox_presto_serializer)
+
+add_library(velox_query_trace_retrieve QueryDataReader.cpp
+                                       QueryMetadataReader.cpp)
+
+target_link_libraries(
+  velox_query_trace_retrieve
+  velox_common_io
+  velox_file
+  velox_core
+  velox_vector
+  velox_connector
+  velox_common_base
+  velox_hive_connector)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(test)
+endif()
diff --git a/velox/exec/trace/QueryDataReader.cpp b/velox/exec/trace/QueryDataReader.cpp
new file mode 100644
index 0000000000000..b234330dd0e53
--- /dev/null
+++ b/velox/exec/trace/QueryDataReader.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryDataReader.h"
+
+#include "velox/common/file/File.h"
+#include "velox/connectors/hive/HiveDataSink.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/exec/TableWriter.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryDataReader::QueryDataReader(std::string path, memory::MemoryPool* pool)
+    : path_(std::move(path)),
+      fs_(filesystems::getFileSystem(path_, nullptr)),
+      pool_(pool),
+      dataType_(getTraceDataType()),
+      dataStream_(getDataInputStream()) {
+  VELOX_CHECK_NOT_NULL(dataType_);
+  VELOX_CHECK_NOT_NULL(dataStream_);
+}
+
+bool QueryDataReader::read(RowVectorPtr& batch) const {
+  if (dataStream_->atEnd()) {
+    batch = nullptr;
+    return false;
+  }
+
+  VectorStreamGroup::read(
+      dataStream_.get(), pool_, dataType_, &batch, &readOptions_);
+  return true;
+}
+
+RowTypePtr QueryDataReader::getTraceDataType() const {
+  const auto summaryFile = fs_->openFileForRead(
+      fmt::format("{}/{}", path_, QueryTraceTraits::kDataSummaryFileName));
+  const auto summary = summaryFile->pread(0, summaryFile->size());
+  VELOX_USER_CHECK(!summary.empty());
+  folly::dynamic obj = folly::parseJson(summary);
+  return ISerializable::deserialize<RowType>(obj["rowType"]);
+}
+
+std::unique_ptr<common::FileInputStream> QueryDataReader::getDataInputStream()
+    const {
+  auto dataFile = fs_->openFileForRead(
+      fmt::format("{}/{}", path_, QueryTraceTraits::kDataFileName));
+  // TODO: Make the buffer size configurable.
+  return std::make_unique<common::FileInputStream>(
+      std::move(dataFile), 1 << 20, pool_);
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryDataReader.h b/velox/exec/trace/QueryDataReader.h
new file mode 100644
index 0000000000000..ad61bde5886f2
--- /dev/null
+++ b/velox/exec/trace/QueryDataReader.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/FileInputStream.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+
+class QueryDataReader {
+ public:
+  explicit QueryDataReader(std::string path, memory::MemoryPool* pool);
+
+  /// Reads from 'dataStream_' and deserializes to 'batch'. Returns false if
+  /// reaches to end of the stream and 'batch' is set to nullptr.
+  bool read(RowVectorPtr& batch) const;
+
+ private:
+  RowTypePtr getTraceDataType() const;
+
+  std::unique_ptr<common::FileInputStream> getDataInputStream() const;
+
+  const std::string path_;
+  const serializer::presto::PrestoVectorSerde::PrestoOptions readOptions_{
+      true,
+      common::CompressionKind_ZSTD, // TODO: Use trace config.
+      /*nullsFirst=*/true};
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  memory::MemoryPool* const pool_;
+  const RowTypePtr dataType_;
+  const std::unique_ptr<common::FileInputStream> dataStream_;
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryDataWriter.cpp b/velox/exec/trace/QueryDataWriter.cpp
new file mode 100644
index 0000000000000..544e7a3d4580f
--- /dev/null
+++ b/velox/exec/trace/QueryDataWriter.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryDataWriter.h"
+#include "velox/common/base/SpillStats.h"
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/TreeOfLosers.h"
+#include "velox/exec/UnorderedStreamReader.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryDataWriter::QueryDataWriter(
+    const std::string& path,
+    memory::MemoryPool* pool)
+    : dirPath_(path),
+      fs_(filesystems::getFileSystem(dirPath_, nullptr)),
+      pool_(pool) {
+  dataFile_ = fs_->openFileForWrite(
+      fmt::format("{}/{}", dirPath_, QueryTraceTraits::kDataFileName));
+  VELOX_CHECK_NOT_NULL(dataFile_);
+}
+
+void QueryDataWriter::write(const RowVectorPtr& rows) {
+  if (batch_ == nullptr) {
+    batch_ = std::make_unique<VectorStreamGroup>(pool_);
+    batch_->createStreamTree(
+        std::static_pointer_cast<const RowType>(rows->type()),
+        1'000,
+        &options_);
+  }
+  batch_->append(rows);
+  dataType_ = rows->type();
+
+  // Serialize and write out each batch.
+  IOBufOutputStream out(
+      *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
+  batch_->flush(&out);
+  batch_->clear();
+  auto iobuf = out.getIOBuf();
+  dataFile_->append(std::move(iobuf));
+}
+
+void QueryDataWriter::finish() {
+  VELOX_CHECK_NOT_NULL(
+      dataFile_, "The query data writer has already been finished");
+  dataFile_->close();
+  dataFile_.reset();
+  batch_.reset();
+  writeSummary();
+}
+
+void QueryDataWriter::writeSummary() const {
+  const auto summaryFilePath =
+      fmt::format("{}/{}", dirPath_, QueryTraceTraits::kDataSummaryFileName);
+  const auto file = fs_->openFileForWrite(summaryFilePath);
+  folly::dynamic obj = folly::dynamic::object;
+  obj[QueryTraceTraits::kDataTypeKey] = dataType_->serialize();
+  file->append(folly::toJson(obj));
+  file->close();
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryDataWriter.h b/velox/exec/trace/QueryDataWriter.h
new file mode 100644
index 0000000000000..435a0bccc00f9
--- /dev/null
+++ b/velox/exec/trace/QueryDataWriter.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+
+/// Used to serialize and write the input vectors from a given operator into a
+/// file.
+class QueryDataWriter {
+ public:
+  explicit QueryDataWriter(const std::string& path, memory::MemoryPool* pool);
+
+  /// Serializes rows and writes out each batch.
+  void write(const RowVectorPtr& rows);
+
+  /// Closes the data file and writes out the data summary.
+  ///
+  /// NOTE: This method should be only called once.
+  void finish();
+
+ private:
+  // Flushes the trace data summaries to the disk.
+  //
+  // TODO: add more summaries such as number of rows etc.
+  void writeSummary() const;
+
+  const std::string dirPath_;
+  // TODO: make 'useLosslessTimestamp' configuerable.
+  const serializer::presto::PrestoVectorSerde::PrestoOptions options_ = {
+      true,
+      common::CompressionKind::CompressionKind_ZSTD,
+      /*nullsFirst=*/true};
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  memory::MemoryPool* const pool_;
+  std::unique_ptr<WriteFile> dataFile_;
+  TypePtr dataType_;
+  std::unique_ptr<VectorStreamGroup> batch_;
+};
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataReader.cpp b/velox/exec/trace/QueryMetadataReader.cpp
new file mode 100644
index 0000000000000..8843aa49a2ab6
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataReader.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryMetadataReader.h"
+
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveDataSink.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/TableWriter.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryMetadataReader::QueryMetadataReader(
+    std::string traceDir,
+    memory::MemoryPool* pool)
+    : traceDir_(std::move(traceDir)),
+      fs_(filesystems::getFileSystem(traceDir_, nullptr)),
+      metaFilePath_(fmt::format(
+          "{}/{}",
+          traceDir_,
+          QueryTraceTraits::kQueryMetaFileName)),
+      pool_(pool) {
+  VELOX_CHECK_NOT_NULL(fs_);
+  VELOX_CHECK(fs_->exists(metaFilePath_));
+}
+
+void QueryMetadataReader::read(
+    std::unordered_map<std::string, std::string>& queryConfigs,
+    std::unordered_map<
+        std::string,
+        std::unordered_map<std::string, std::string>>& connectorProperties,
+    core::PlanNodePtr& queryPlan) const {
+  const auto file = fs_->openFileForRead(metaFilePath_);
+  VELOX_CHECK_NOT_NULL(file);
+  const auto metadata = file->pread(0, file->size());
+  VELOX_USER_CHECK(!metadata.empty());
+  folly::dynamic obj = folly::parseJson(metadata);
+
+  const auto& queryConfigObj = obj[QueryTraceTraits::kQueryConfigKey];
+  for (const auto& [key, value] : queryConfigObj.items()) {
+    queryConfigs[key.asString()] = value.asString();
+  }
+
+  const auto& connectorPropertiesObj =
+      obj[QueryTraceTraits::kConnectorPropertiesKey];
+  for (const auto& [connectorId, configs] : connectorPropertiesObj.items()) {
+    const auto connectorIdStr = connectorId.asString();
+    connectorProperties[connectorIdStr] = {};
+    for (const auto& [key, value] : configs.items()) {
+      connectorProperties[connectorIdStr][key.asString()] = value.asString();
+    }
+  }
+
+  queryPlan = ISerializable::deserialize<core::PlanNode>(
+      obj[QueryTraceTraits::kPlanNodeKey], pool_);
+}
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataReader.h b/velox/exec/trace/QueryMetadataReader.h
new file mode 100644
index 0000000000000..71217653d4dc3
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataReader.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+class QueryMetadataReader {
+ public:
+  explicit QueryMetadataReader(std::string traceDir, memory::MemoryPool* pool);
+
+  void read(
+      std::unordered_map<std::string, std::string>& queryConfigs,
+      std::unordered_map<
+          std::string,
+          std::unordered_map<std::string, std::string>>& connectorProperties,
+      core::PlanNodePtr& queryPlan) const;
+
+ private:
+  const std::string traceDir_;
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  const std::string metaFilePath_;
+  memory::MemoryPool* const pool_;
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataWriter.cpp b/velox/exec/trace/QueryMetadataWriter.cpp
new file mode 100644
index 0000000000000..beba2e8097469
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataWriter.cpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryMetadataWriter.h"
+#include "velox/common/config/Config.h"
+#include "velox/common/file/File.h"
+#include "velox/connectors/hive/HiveDataSink.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/exec/TableWriter.h"
+#include "velox/exec/trace/QueryTraceTraits.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryMetadataWriter::QueryMetadataWriter(
+    std::string traceDir,
+    memory::MemoryPool* pool)
+    : traceDir_(std::move(traceDir)),
+      fs_(filesystems::getFileSystem(traceDir_, nullptr)),
+      metaFilePath_(fmt::format(
+          "{}/{}",
+          traceDir_,
+          QueryTraceTraits::kQueryMetaFileName)),
+      pool_(pool) {
+  VELOX_CHECK_NOT_NULL(fs_);
+  VELOX_CHECK(!fs_->exists(metaFilePath_));
+}
+
+void QueryMetadataWriter::write(
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    const core::PlanNodePtr& planNode) {
+  VELOX_CHECK(!finished_, "Query metadata can only be written once");
+  finished_ = true;
+  folly::dynamic queryConfigObj = folly::dynamic::object;
+  const auto configValues = queryCtx->queryConfig().rawConfigsCopy();
+  for (const auto& [key, value] : configValues) {
+    queryConfigObj[key] = value;
+  }
+
+  folly::dynamic connectorPropertiesObj = folly::dynamic::object;
+  for (const auto& [connectorId, configs] :
+       queryCtx->connectorSessionProperties()) {
+    folly::dynamic obj = folly::dynamic::object;
+    for (const auto& [key, value] : configs->rawConfigsCopy()) {
+      obj[key] = value;
+    }
+    connectorPropertiesObj[connectorId] = obj;
+  }
+
+  folly::dynamic metaObj = folly::dynamic::object;
+  metaObj[QueryTraceTraits::kQueryConfigKey] = queryConfigObj;
+  metaObj[QueryTraceTraits::kConnectorPropertiesKey] = connectorPropertiesObj;
+  metaObj[QueryTraceTraits::kPlanNodeKey] = planNode->serialize();
+
+  const auto metaStr = folly::toJson(metaObj);
+  const auto file = fs_->openFileForWrite(metaFilePath_);
+  file->append(metaStr);
+  file->close();
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryMetadataWriter.h b/velox/exec/trace/QueryMetadataWriter.h
new file mode 100644
index 0000000000000..f2cc661238514
--- /dev/null
+++ b/velox/exec/trace/QueryMetadataWriter.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::exec::trace {
+class QueryMetadataWriter {
+ public:
+  explicit QueryMetadataWriter(std::string traceDir, memory::MemoryPool* pool);
+
+  void write(
+      const std::shared_ptr<core::QueryCtx>& queryCtx,
+      const core::PlanNodePtr& planNode);
+
+ private:
+  const std::string traceDir_;
+  const std::shared_ptr<filesystems::FileSystem> fs_;
+  const std::string metaFilePath_;
+  memory::MemoryPool* const pool_;
+  bool finished_{false};
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceConfig.cpp b/velox/exec/trace/QueryTraceConfig.cpp
new file mode 100644
index 0000000000000..2437a632fb432
--- /dev/null
+++ b/velox/exec/trace/QueryTraceConfig.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryTraceConfig.h"
+
+namespace facebook::velox::exec::trace {
+
+QueryTraceConfig::QueryTraceConfig(
+    std::unordered_set<std::string> _queryNodeIds,
+    std::string _queryTraceDir)
+    : queryNodes(std::move(_queryNodeIds)),
+      queryTraceDir(std::move(_queryTraceDir)) {}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceConfig.h b/velox/exec/trace/QueryTraceConfig.h
new file mode 100644
index 0000000000000..8afcbf22fb53d
--- /dev/null
+++ b/velox/exec/trace/QueryTraceConfig.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_set>
+
+namespace facebook::velox::exec::trace {
+struct QueryTraceConfig {
+  /// Target query trace nodes
+  std::unordered_set<std::string> queryNodes;
+  /// Base dir of query trace, normmaly it is $prefix/$taskId.
+  std::string queryTraceDir;
+
+  QueryTraceConfig(
+      std::unordered_set<std::string> _queryNodeIds,
+      std::string _queryTraceDir);
+
+  QueryTraceConfig() = default;
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceTraits.h b/velox/exec/trace/QueryTraceTraits.h
new file mode 100644
index 0000000000000..5e3a91f783d3e
--- /dev/null
+++ b/velox/exec/trace/QueryTraceTraits.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::exec::trace {
+/// Defines the shared constants used by query trace implementation.
+struct QueryTraceTraits {
+  static inline const std::string kPlanNodeKey = "planNode";
+  static inline const std::string kQueryConfigKey = "queryConfig";
+  static inline const std::string kDataTypeKey = "rowType";
+  static inline const std::string kConnectorPropertiesKey =
+      "connectorProperties";
+
+  static inline const std::string kQueryMetaFileName = "query_meta.json";
+  static inline const std::string kDataSummaryFileName = "data_summary.json";
+  static inline const std::string kDataFileName = "trace.data";
+};
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/test/CMakeLists.txt b/velox/exec/trace/test/CMakeLists.txt
new file mode 100644
index 0000000000000..9c4ffe9dd3585
--- /dev/null
+++ b/velox/exec/trace/test/CMakeLists.txt
@@ -0,0 +1,31 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_executable(velox_exec_trace_test QueryTraceTest.cpp)
+
+add_test(
+  NAME velox_exec_trace_test
+  COMMAND velox_exec_trace_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+set_tests_properties(velox_exec_trace_test PROPERTIES TIMEOUT 3000)
+
+target_link_libraries(
+  velox_exec_trace_test
+  velox_exec
+  velox_exec_test_lib
+  velox_memory
+  velox_query_trace_exec
+  velox_query_trace_retrieve
+  velox_vector_fuzzer)
diff --git a/velox/exec/trace/test/QueryTraceTest.cpp b/velox/exec/trace/test/QueryTraceTest.cpp
new file mode 100644
index 0000000000000..765eeccaaf532
--- /dev/null
+++ b/velox/exec/trace/test/QueryTraceTest.cpp
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+#include <algorithm>
+#include <memory>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/trace/QueryDataReader.h"
+#include "velox/exec/trace/QueryDataWriter.h"
+#include "velox/exec/trace/QueryMetadataReader.h"
+#include "velox/exec/trace/QueryMetadataWriter.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::exec::test {
+class QueryTracerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+    HiveConnectorTestBase::SetUpTestCase();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveTableHandle::registerSerDe();
+    connector::hive::LocationHandle::registerSerDe();
+    connector::hive::HiveColumnHandle::registerSerDe();
+    connector::hive::HiveInsertTableHandle::registerSerDe();
+    core::PlanNode::registerSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  static VectorFuzzer::Options getFuzzerOptions() {
+    return VectorFuzzer::Options{
+        .vectorSize = 16,
+        .nullRatio = 0.2,
+        .stringLength = 1024,
+        .stringVariableLength = false,
+        .allowLazyVector = false,
+    };
+  }
+
+  QueryTracerTest() : vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
+    filesystems::registerLocalFileSystem();
+  }
+
+  RowTypePtr generateTypes(size_t numColumns) {
+    std::vector<std::string> names;
+    names.reserve(numColumns);
+    std::vector<TypePtr> types;
+    types.reserve(numColumns);
+    for (auto i = 0; i < numColumns; ++i) {
+      names.push_back(fmt::format("c{}", i));
+      types.push_back(vectorFuzzer_.randType((2)));
+    }
+    return ROW(std::move(names), std::move(types));
+    ;
+  }
+
+  bool isSamePlan(
+      const core::PlanNodePtr& left,
+      const core::PlanNodePtr& right) {
+    if (left->id() != right->id() || left->name() != right->name()) {
+      return false;
+    }
+
+    if (left->sources().size() != right->sources().size()) {
+      return false;
+    }
+
+    for (auto i = 0; i < left->sources().size(); ++i) {
+      isSamePlan(left->sources().at(i), right->sources().at(i));
+    }
+    return true;
+  }
+
+  VectorFuzzer vectorFuzzer_;
+};
+
+TEST_F(QueryTracerTest, traceData) {
+  const auto rowType = generateTypes(5);
+  std::vector<RowVectorPtr> inputVectors;
+  constexpr auto numBatch = 3;
+  inputVectors.reserve(numBatch);
+  for (auto i = 0; i < numBatch; ++i) {
+    inputVectors.push_back(vectorFuzzer_.fuzzInputRow(rowType));
+  }
+
+  const auto outputDir = TempDirectoryPath::create();
+  auto writer = trace::QueryDataWriter(outputDir->getPath(), pool());
+  for (auto i = 0; i < numBatch; ++i) {
+    writer.write(inputVectors[i]);
+  }
+  writer.finish();
+
+  const auto reader = trace::QueryDataReader(outputDir->getPath(), pool());
+  RowVectorPtr actual;
+  size_t numOutputVectors{0};
+  while (reader.read(actual)) {
+    const auto expected = inputVectors[numOutputVectors];
+    const auto size = actual->size();
+    ASSERT_EQ(size, expected->size());
+    for (auto i = 0; i < size; ++i) {
+      actual->compare(expected.get(), i, i, {.nullsFirst = true});
+    }
+    ++numOutputVectors;
+  }
+  ASSERT_EQ(numOutputVectors, inputVectors.size());
+}
+
+TEST_F(QueryTracerTest, traceMetadata) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {BIGINT(), SMALLINT(), TINYINT(), VARCHAR(), VARCHAR(), VARCHAR()});
+  std::vector<RowVectorPtr> rows;
+  constexpr auto numBatch = 1;
+  rows.reserve(numBatch);
+  for (auto i = 0; i < numBatch; ++i) {
+    rows.push_back(vectorFuzzer_.fuzzRow(rowType, 2));
+  }
+
+  const auto outputDir = TempDirectoryPath::create();
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values(rows, false)
+          .project({"c0", "c1", "c2"})
+          .hashJoin(
+              {"c0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator)
+                  .values(rows, true)
+                  .singleAggregation({"c0", "c1"}, {"min(c2)"})
+                  .project({"c0 AS u0", "c1 AS u1", "a0 AS u2"})
+                  .planNode(),
+              "c0 < 135",
+              {"c0", "c1", "c2"},
+              core::JoinType::kInner)
+          .planNode();
+  const auto expectedQueryConfigs =
+      std::unordered_map<std::string, std::string>{
+          {core::QueryConfig::kSpillEnabled, "true"},
+          {core::QueryConfig::kSpillNumPartitionBits, "17"},
+          {"key1", "value1"},
+      };
+  const auto expectedConnectorProperties =
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{
+          {"test_trace",
+           std::make_shared<config::ConfigBase>(
+               std::unordered_map<std::string, std::string>{
+                   {"cKey1", "cVal1"}})}};
+  const auto queryCtx = core::QueryCtx::create(
+      executor_.get(),
+      core::QueryConfig(expectedQueryConfigs),
+      expectedConnectorProperties);
+  auto writer = trace::QueryMetadataWriter(outputDir->getPath(), pool());
+  writer.write(queryCtx, planNode);
+
+  std::unordered_map<std::string, std::string> acutalQueryConfigs;
+  std::unordered_map<std::string, std::unordered_map<std::string, std::string>>
+      actualConnectorProperties;
+  core::PlanNodePtr actualQueryPlan;
+  auto reader = trace::QueryMetadataReader(outputDir->getPath(), pool());
+  reader.read(acutalQueryConfigs, actualConnectorProperties, actualQueryPlan);
+
+  ASSERT_TRUE(isSamePlan(actualQueryPlan, planNode));
+  ASSERT_EQ(acutalQueryConfigs.size(), expectedQueryConfigs.size());
+  for (const auto& [key, value] : acutalQueryConfigs) {
+    ASSERT_EQ(acutalQueryConfigs.at(key), expectedQueryConfigs.at(key));
+  }
+
+  ASSERT_EQ(
+      actualConnectorProperties.size(), expectedConnectorProperties.size());
+  ASSERT_EQ(actualConnectorProperties.count("test_trace"), 1);
+  const auto expectedConnectorConfigs =
+      expectedConnectorProperties.at("test_trace")->rawConfigsCopy();
+  const auto actualConnectorConfigs =
+      actualConnectorProperties.at("test_trace");
+  for (const auto& [key, value] : actualConnectorConfigs) {
+    ASSERT_EQ(actualConnectorConfigs.at(key), expectedConnectorConfigs.at(key));
+  }
+}
+} // namespace facebook::velox::exec::test

From df771053f1987592fd7677960bce0482c9bbc36e Mon Sep 17 00:00:00 2001
From: Karthikeyan Natarajan <karthikeyann@users.noreply.github.com>
Date: Wed, 21 Aug 2024 11:27:57 -0700
Subject: [PATCH 02/24] Add separate map for Custom Bridges (#10626)

Summary:
Since both Velox bridges, and custom bridges were stored in same map, which did not allow translators to replace/add custom bridges. This change fixes this issue by adding a new map for custom bridges.

A unit test is added to replace the Velox operators with custom operators, and custom bridges, using driver adapter and translator.

Background: To enable running velox operators using libcudf, velox operators will be replaced by custom operators using driver adapter. Bridges are not replaced by driver adapter. But these new operators should also have custom bridges associated with it, to communicate between Build and Probe operators. To create these bridges, we use translator interface provided by velox. Since already a Bridge is stored in a map `bridges` for velox bridges, the translator call does not replace existing bridge and fails silently. This PR separates this map to 2 maps, one for velox join node, another for custom bridges created by translators. This change also helps other driver adaptor implementation (such as wave) to communicate between pipelines using custom bridges.

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10626

Reviewed By: Yuhta

Differential Revision: D61549695

Pulled By: kgpai

fbshipit-source-id: ca58f39f55bcf7a57fc457478a0b489b9eda9f98
---
 velox/exec/Task.cpp                      |  59 +++-
 velox/exec/Task.h                        |   7 +-
 velox/exec/TaskStructs.h                 |   5 +
 velox/exec/tests/CMakeLists.txt          |   9 +
 velox/exec/tests/OperatorReplacement.cpp | 386 +++++++++++++++++++++++
 5 files changed, 451 insertions(+), 15 deletions(-)
 create mode 100644 velox/exec/tests/OperatorReplacement.cpp

diff --git a/velox/exec/Task.cpp b/velox/exec/Task.cpp
index 8bf121569b248..38006f9baf531 100644
--- a/velox/exec/Task.cpp
+++ b/velox/exec/Task.cpp
@@ -1098,6 +1098,9 @@ std::vector<std::shared_ptr<Driver>> Task::createDriversLocked(
   for (auto& bridgeEntry : splitGroupState.bridges) {
     bridgeEntry.second->start();
   }
+  for (auto& bridgeEntry : splitGroupState.custom_bridges) {
+    bridgeEntry.second->start();
+  }
 
   return drivers;
 }
@@ -1753,8 +1756,12 @@ void Task::addHashJoinBridgesLocked(
     const std::vector<core::PlanNodeId>& planNodeIds) {
   auto& splitGroupState = splitGroupStates_[splitGroupId];
   for (const auto& planNodeId : planNodeIds) {
-    splitGroupState.bridges.emplace(
-        planNodeId, std::make_shared<HashJoinBridge>());
+    auto const inserted =
+        splitGroupState.bridges
+            .emplace(planNodeId, std::make_shared<HashJoinBridge>())
+            .second;
+    VELOX_CHECK(
+        inserted, "Join bridge for node {} is already present", planNodeId);
   }
 }
 
@@ -1764,7 +1771,13 @@ void Task::addCustomJoinBridgesLocked(
   auto& splitGroupState = splitGroupStates_[splitGroupId];
   for (const auto& planNode : planNodes) {
     if (auto joinBridge = Operator::joinBridgeFromPlanNode(planNode)) {
-      splitGroupState.bridges.emplace(planNode->id(), std::move(joinBridge));
+      auto const inserted = splitGroupState.custom_bridges
+                                .emplace(planNode->id(), std::move(joinBridge))
+                                .second;
+      VELOX_CHECK(
+          inserted,
+          "Join bridge for node {} is already present",
+          planNode->id());
       return;
     }
   }
@@ -1773,7 +1786,7 @@ void Task::addCustomJoinBridgesLocked(
 std::shared_ptr<JoinBridge> Task::getCustomJoinBridge(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
-  return getJoinBridgeInternal<JoinBridge>(splitGroupId, planNodeId);
+  return getCustomJoinBridgeInternal(splitGroupId, planNodeId);
 }
 
 void Task::addNestedLoopJoinBridgesLocked(
@@ -1781,8 +1794,12 @@ void Task::addNestedLoopJoinBridgesLocked(
     const std::vector<core::PlanNodeId>& planNodeIds) {
   auto& splitGroupState = splitGroupStates_[splitGroupId];
   for (const auto& planNodeId : planNodeIds) {
-    splitGroupState.bridges.emplace(
-        planNodeId, std::make_shared<NestedLoopJoinBridge>());
+    auto const inserted =
+        splitGroupState.bridges
+            .emplace(planNodeId, std::make_shared<NestedLoopJoinBridge>())
+            .second;
+    VELOX_CHECK(
+        inserted, "Join bridge for node {} is already present", planNodeId);
   }
 }
 
@@ -1795,7 +1812,8 @@ std::shared_ptr<HashJoinBridge> Task::getHashJoinBridge(
 std::shared_ptr<HashJoinBridge> Task::getHashJoinBridgeLocked(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
-  return getJoinBridgeInternalLocked<HashJoinBridge>(splitGroupId, planNodeId);
+  return getJoinBridgeInternalLocked<HashJoinBridge>(
+      splitGroupId, planNodeId, &SplitGroupState::bridges);
 }
 
 std::shared_ptr<NestedLoopJoinBridge> Task::getNestedLoopJoinBridge(
@@ -1809,26 +1827,28 @@ std::shared_ptr<TBridgeType> Task::getJoinBridgeInternal(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
   std::lock_guard<std::timed_mutex> l(mutex_);
-  return getJoinBridgeInternalLocked<TBridgeType>(splitGroupId, planNodeId);
+  return getJoinBridgeInternalLocked<TBridgeType>(
+      splitGroupId, planNodeId, &SplitGroupState::bridges);
 }
 
-template <class TBridgeType>
+template <class TBridgeType, typename MemberType>
 std::shared_ptr<TBridgeType> Task::getJoinBridgeInternalLocked(
     uint32_t splitGroupId,
-    const core::PlanNodeId& planNodeId) {
+    const core::PlanNodeId& planNodeId,
+    MemberType SplitGroupState::*bridges_member) {
   const auto& splitGroupState = splitGroupStates_[splitGroupId];
 
-  auto it = splitGroupState.bridges.find(planNodeId);
-  if (it == splitGroupState.bridges.end()) {
+  auto it = (splitGroupState.*bridges_member).find(planNodeId);
+  if (it == (splitGroupState.*bridges_member).end()) {
     // We might be looking for a bridge between grouped and ungrouped execution.
     // It will belong to the 'ungrouped' state.
     if (isGroupedExecution() && splitGroupId != kUngroupedGroupId) {
       return getJoinBridgeInternalLocked<TBridgeType>(
-          kUngroupedGroupId, planNodeId);
+          kUngroupedGroupId, planNodeId, bridges_member);
     }
   }
   VELOX_CHECK(
-      it != splitGroupState.bridges.end(),
+      it != (splitGroupState.*bridges_member).end(),
       "Join bridge for plan node ID {} not found for group {}, task {}",
       planNodeId,
       splitGroupId,
@@ -1842,6 +1862,14 @@ std::shared_ptr<TBridgeType> Task::getJoinBridgeInternalLocked(
   return bridge;
 }
 
+std::shared_ptr<JoinBridge> Task::getCustomJoinBridgeInternal(
+    uint32_t splitGroupId,
+    const core::PlanNodeId& planNodeId) {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  return getJoinBridgeInternalLocked<JoinBridge>(
+      splitGroupId, planNodeId, &SplitGroupState::custom_bridges);
+}
+
 //  static
 std::string Task::shortId(const std::string& id) {
   if (id.size() < 12) {
@@ -1958,6 +1986,9 @@ ContinueFuture Task::terminate(TaskState terminalState) {
       for (auto& pair : splitGroupState.second.bridges) {
         oldBridges.emplace_back(std::move(pair.second));
       }
+      for (auto& pair : splitGroupState.second.custom_bridges) {
+        oldBridges.emplace_back(std::move(pair.second));
+      }
       splitGroupStates.push_back(std::move(splitGroupState.second));
     }
 
diff --git a/velox/exec/Task.h b/velox/exec/Task.h
index dae427eb97c91..433df9a0451e5 100644
--- a/velox/exec/Task.h
+++ b/velox/exec/Task.h
@@ -835,8 +835,13 @@ class Task : public std::enable_shared_from_this<Task> {
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId);
 
-  template <class TBridgeType>
+  template <class TBridgeType, typename MemberType>
   std::shared_ptr<TBridgeType> getJoinBridgeInternalLocked(
+      uint32_t splitGroupId,
+      const core::PlanNodeId& planNodeId,
+      MemberType SplitGroupState::*bridges_member);
+
+  std::shared_ptr<JoinBridge> getCustomJoinBridgeInternal(
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId);
 
diff --git a/velox/exec/TaskStructs.h b/velox/exec/TaskStructs.h
index 5585b53098e2a..3ddc147b65274 100644
--- a/velox/exec/TaskStructs.h
+++ b/velox/exec/TaskStructs.h
@@ -88,7 +88,11 @@ struct LocalExchangeState {
 /// Stores inter-operator state (exchange, bridges) for split groups.
 struct SplitGroupState {
   /// Map from the plan node id of the join to the corresponding JoinBridge.
+  /// This map will contain only HashJoinBridge and NestedLoopJoinBridge.
   std::unordered_map<core::PlanNodeId, std::shared_ptr<JoinBridge>> bridges;
+  /// This map will contain all other custom bridges.
+  std::unordered_map<core::PlanNodeId, std::shared_ptr<JoinBridge>>
+      custom_bridges;
 
   /// Holds states for Task::allPeersFinished.
   std::unordered_map<core::PlanNodeId, BarrierState> barriers;
@@ -125,6 +129,7 @@ struct SplitGroupState {
   void clear() {
     if (!mixedExecutionMode) {
       bridges.clear();
+      custom_bridges.clear();
       barriers.clear();
     }
     localMergeSources.clear();
diff --git a/velox/exec/tests/CMakeLists.txt b/velox/exec/tests/CMakeLists.txt
index 00230f53464fa..32a46e398432b 100644
--- a/velox/exec/tests/CMakeLists.txt
+++ b/velox/exec/tests/CMakeLists.txt
@@ -327,3 +327,12 @@ add_test(
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 target_link_libraries(
   cpr_http_client_test cpr::cpr GTest::gtest GTest::gtest_main)
+
+add_executable(velox_driver_test OperatorReplacement.cpp Main.cpp)
+add_test(
+  NAME velox_driver_test
+  COMMAND velox_driver_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(
+  velox_driver_test velox_exec velox_exec_test_lib GTest::gtest)
diff --git a/velox/exec/tests/OperatorReplacement.cpp b/velox/exec/tests/OperatorReplacement.cpp
new file mode 100644
index 0000000000000..dd39ea32e7f7b
--- /dev/null
+++ b/velox/exec/tests/OperatorReplacement.cpp
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/exec/JoinBridge.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace {
+using ReplacedJoinNode = typename facebook::velox::core::HashJoinNode;
+
+class CustomJoinBridge : public JoinBridge {
+ public:
+  void setNumRows(std::optional<int32_t> numRows) {
+    std::vector<ContinuePromise> promises;
+    {
+      std::lock_guard<std::mutex> l(mutex_);
+      VELOX_CHECK(!numRows_.has_value(), "setNumRows may be called only once");
+      numRows_ = numRows;
+      promises = std::move(promises_);
+    }
+    notify(std::move(promises));
+  }
+
+  std::optional<int32_t> numRowsOrFuture(ContinueFuture* future) {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(!cancelled_, "Getting data after the build side is aborted");
+    if (numRows_.has_value()) {
+      return numRows_;
+    }
+    promises_.emplace_back("CustomJoinBridge::numRowsOrFuture");
+    *future = promises_.back().getSemiFuture();
+    return std::nullopt;
+  }
+
+ private:
+  std::optional<int32_t> numRows_;
+};
+
+class CustomJoinBuild : public Operator {
+ public:
+  CustomJoinBuild(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      std::shared_ptr<const ReplacedJoinNode> joinNode)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNode->id(),
+            "CustomJoinBuild") {}
+  CustomJoinBuild(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const core::PlanNodeId& joinNodeid)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNodeid,
+            "CustomJoinBuild") {}
+
+  void addInput(RowVectorPtr input) override {
+    auto inputSize = input->size();
+    if (inputSize > 0) {
+      numRows_ += inputSize;
+    }
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  RowVectorPtr getOutput() override {
+    return nullptr;
+  }
+
+  void noMoreInput() override {
+    Operator::noMoreInput();
+    std::vector<ContinuePromise> promises;
+    std::vector<std::shared_ptr<Driver>> peers;
+    // The last Driver to hit CustomJoinBuild::finish gathers the data from
+    // all build Drivers and hands it over to the probe side. At this
+    // point all build Drivers are continued and will free their
+    // state. allPeersFinished is true only for the last Driver of the
+    // build pipeline.
+    if (!operatorCtx_->task()->allPeersFinished(
+            planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
+      return;
+    }
+
+    for (auto& peer : peers) {
+      auto op = peer->findOperator(planNodeId());
+      auto* build = dynamic_cast<CustomJoinBuild*>(op);
+      VELOX_CHECK(build);
+      numRows_ += build->numRows_;
+    }
+
+    // Realize the promises so that the other Drivers (which were not
+    // the last to finish) can continue from the barrier and finish.
+    peers.clear();
+    for (auto& promise : promises) {
+      promise.setValue();
+    }
+
+    auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+        operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+    auto customJoinBridge =
+        std::dynamic_pointer_cast<CustomJoinBridge>(joinBridge);
+
+    // checks
+    VELOX_CHECK_NOT_NULL(
+        customJoinBridge,
+        "Join bridge for plan node ID is of the wrong type: {}",
+        planNodeId());
+    customJoinBridge->setNumRows(std::make_optional(numRows_));
+  }
+
+  BlockingReason isBlocked(ContinueFuture* future) override {
+    if (!future_.valid()) {
+      return BlockingReason::kNotBlocked;
+    }
+    *future = std::move(future_);
+    return BlockingReason::kWaitForJoinBuild;
+  }
+
+  bool isFinished() override {
+    return !future_.valid() && noMoreInput_;
+  }
+
+ private:
+  int32_t numRows_ = 0;
+
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+};
+
+class CustomJoinProbe : public Operator {
+ public:
+  CustomJoinProbe(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      std::shared_ptr<const ReplacedJoinNode> joinNode)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNode->id(),
+            "CustomJoinProbe") {}
+  CustomJoinProbe(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const core::PlanNodeId& joinNodeid)
+      : Operator(
+            driverCtx,
+            nullptr,
+            operatorId,
+            joinNodeid,
+            "CustomJoinProbe") {}
+
+  bool needsInput() const override {
+    return !finished_ && input_ == nullptr;
+  }
+
+  void addInput(RowVectorPtr input) override {
+    input_ = std::move(input);
+  }
+
+  RowVectorPtr getOutput() override {
+    if (!input_) {
+      return nullptr;
+    }
+
+    const auto inputSize = input_->size();
+    if (remainingLimit_ <= inputSize) {
+      finished_ = true;
+    }
+
+    if (remainingLimit_ >= inputSize) {
+      remainingLimit_ -= inputSize;
+      auto output = input_;
+      input_.reset();
+      return output;
+    }
+
+    // Return nullptr if there is no data to return.
+    if (remainingLimit_ == 0) {
+      input_.reset();
+      return nullptr;
+    }
+
+    auto output = std::make_shared<RowVector>(
+        input_->pool(),
+        input_->type(),
+        input_->nulls(),
+        remainingLimit_,
+        input_->children());
+    input_.reset();
+    remainingLimit_ = 0;
+    return output;
+  }
+
+  BlockingReason isBlocked(ContinueFuture* future) override {
+    if (numRows_.has_value()) {
+      return BlockingReason::kNotBlocked;
+    }
+
+    auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+        operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+    auto customJoinBridge =
+        std::dynamic_pointer_cast<CustomJoinBridge>(joinBridge);
+
+    // checks
+    VELOX_CHECK_NOT_NULL(
+        customJoinBridge,
+        "Join bridge for plan node ID is of the wrong type: {}",
+        planNodeId());
+    auto numRows = customJoinBridge->numRowsOrFuture(future);
+
+    if (!numRows.has_value()) {
+      return BlockingReason::kWaitForJoinBuild;
+    }
+    numRows_ = std::move(numRows);
+    remainingLimit_ = numRows_.value();
+
+    return BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override {
+    return finished_ || (noMoreInput_ && input_ == nullptr);
+  }
+
+ private:
+  int32_t remainingLimit_;
+  std::optional<int32_t> numRows_;
+
+  bool finished_{false};
+};
+
+class CustomJoinBridgeTranslator : public Operator::PlanNodeTranslator {
+  std::unique_ptr<Operator>
+  toOperator(DriverCtx* ctx, int32_t id, const core::PlanNodePtr& node) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const ReplacedJoinNode>(node)) {
+      return std::make_unique<CustomJoinProbe>(id, ctx, joinNode);
+    }
+    return nullptr;
+  }
+
+  std::unique_ptr<JoinBridge> toJoinBridge(const core::PlanNodePtr& node) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const ReplacedJoinNode>(node)) {
+      auto joinBridge = std::make_unique<CustomJoinBridge>();
+      return std::move(joinBridge);
+    }
+    return nullptr;
+  }
+
+  OperatorSupplier toOperatorSupplier(const core::PlanNodePtr& node) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const ReplacedJoinNode>(node)) {
+      return [joinNode](int32_t operatorId, DriverCtx* ctx) {
+        return std::make_unique<CustomJoinBuild>(operatorId, ctx, joinNode);
+      };
+    }
+    return nullptr;
+  }
+};
+
+bool CustomDriverAdapter(
+    const exec::DriverFactory& driverFactory_,
+    exec::Driver& driver_) {
+  auto operators = driver_.operators();
+  // Make sure operator states are initialized.  We will need to inspect some of
+  // them during the transformation.
+  driver_.initializeOperators();
+  auto ctx = driver_.driverCtx();
+  // Replace HashBuild and HashProbe operators with CustomHashBuild and
+  // CustomHashProbe operators.
+  for (int32_t operatorIndex = 0; operatorIndex < operators.size();
+       ++operatorIndex) {
+    std::vector<std::unique_ptr<exec::Operator>> replace_op;
+
+    facebook::velox::exec::Operator* oper = operators[operatorIndex];
+    VELOX_CHECK(oper);
+    if (auto joinBuildOp =
+            dynamic_cast<facebook::velox::exec::HashBuild*>(oper)) {
+      auto planid = joinBuildOp->planNodeId();
+      auto id = joinBuildOp->operatorId();
+      replace_op.push_back(std::make_unique<CustomJoinBuild>(id, ctx, planid));
+      replace_op[0]->initialize();
+      auto replaced = driverFactory_.replaceOperators(
+          driver_, operatorIndex, operatorIndex + 1, std::move(replace_op));
+    } else if (
+        auto joinProbeOp =
+            dynamic_cast<facebook::velox::exec::HashProbe*>(oper)) {
+      auto planid = joinProbeOp->planNodeId();
+      auto id = joinProbeOp->operatorId();
+      replace_op.push_back(std::make_unique<CustomJoinProbe>(id, ctx, planid));
+      replace_op[0]->initialize();
+      auto replaced = driverFactory_.replaceOperators(
+          driver_, operatorIndex, operatorIndex + 1, std::move(replace_op));
+    }
+  }
+  return true;
+}
+
+void registerCustomDriver() {
+  exec::DriverAdapter custAdapter{"opRep", {}, CustomDriverAdapter};
+  exec::DriverFactory::registerAdapter(custAdapter);
+}
+
+void registerOperatorReplacement() {
+  // Registering Translator
+  exec::Operator::registerOperator(
+      std::make_unique<CustomJoinBridgeTranslator>());
+  // Registering Custom Driver Adapter
+  registerCustomDriver();
+}
+} // namespace
+
+/// This test will show the operator replacement with other operators using
+/// driver adapter and usage of custom join bridge for replaced velox
+/// join operators. It uses same custom operators from CustomJoinTest,
+/// which will emit number of input rows.
+class OperatorReplacementTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    registerOperatorReplacement();
+  }
+
+  RowVectorPtr makeSimpleRowVector(vector_size_t size) {
+    return makeRowVector(
+        {makeFlatVector<int32_t>(size, [](auto row) { return row; })});
+  }
+
+  void testOperatorReplacement(
+      int32_t numThreads,
+      const std::vector<RowVectorPtr>& leftBatch,
+      const std::vector<RowVectorPtr>& rightBatch,
+      const std::string& referenceQuery) {
+    createDuckDbTable("t", {leftBatch});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+    CursorParameters params;
+    params.maxDrivers = numThreads;
+    params.planNode = PlanBuilder(planNodeIdGenerator)
+                          .values({leftBatch}, false)
+                          .hashJoin(
+                              {"c0"},
+                              {"u1"},
+                              PlanBuilder(planNodeIdGenerator)
+                                  .values(rightBatch, false)
+                                  .project({"c0 AS u1"})
+                                  .planNode(),
+                              "",
+                              {"c0"})
+                          .project({"c0"})
+                          .planNode();
+
+    OperatorTestBase::assertQuery(params, referenceQuery);
+  }
+};
+
+TEST_F(OperatorReplacementTest, basic) {
+  auto leftBatch = {makeSimpleRowVector(100)};
+  auto rightBatch = {makeSimpleRowVector(10)};
+  testOperatorReplacement(
+      1, leftBatch, rightBatch, "SELECT c0 FROM t LIMIT 10");
+}

From 74a31830765341f7e0e5214248cbc070d5a5b153 Mon Sep 17 00:00:00 2001
From: hitarth <hitarth@uber.com>
Date: Wed, 21 Aug 2024 11:29:49 -0700
Subject: [PATCH 03/24] Handle array of map and array of array case accurately
 in parquet reader (#9728)

Summary:
Handle array of map and array of array case accurately in parquet reader while parsing schema. This should fix https://github.com/facebookincubator/velox/issues/9238

Pull Request resolved: https://github.com/facebookincubator/velox/pull/9728

Reviewed By: Yuhta

Differential Revision: D61550387

Pulled By: kgpai

fbshipit-source-id: 989dc46785371d1f86d4e277cfaf5eeb1761f311
---
 velox/dwio/parquet/reader/ParquetReader.cpp   |  28 +++-
 ...rray_of_map_of_int_key_array_value.parquet | Bin 0 -> 43558 bytes
 ...ray_of_map_of_int_key_struct_value.parquet | Bin 0 -> 57932 bytes
 .../examples/struct_of_array_of_array.parquet | Bin 0 -> 86749 bytes
 .../tests/reader/ParquetReaderTest.cpp        | 149 ++++++++++++++++++
 5 files changed, 176 insertions(+), 1 deletion(-)
 create mode 100644 velox/dwio/parquet/tests/examples/array_of_map_of_int_key_array_value.parquet
 create mode 100644 velox/dwio/parquet/tests/examples/array_of_map_of_int_key_struct_value.parquet
 create mode 100644 velox/dwio/parquet/tests/examples/struct_of_array_of_array.parquet

diff --git a/velox/dwio/parquet/reader/ParquetReader.cpp b/velox/dwio/parquet/reader/ParquetReader.cpp
index 635366f19f136..9200886e8eb4d 100644
--- a/velox/dwio/parquet/reader/ParquetReader.cpp
+++ b/velox/dwio/parquet/reader/ParquetReader.cpp
@@ -300,6 +300,33 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
 
     if (schemaElement.__isset.converted_type) {
       switch (schemaElement.converted_type) {
+        case thrift::ConvertedType::LIST: {
+          VELOX_CHECK_EQ(children.size(), 1);
+          const auto& child = children[0];
+          isRepeated = true;
+          // In case the child is a MAP or current element is repeated then
+          // wrap child around additional ARRAY
+          if (child->type()->kind() == TypeKind::MAP ||
+              schemaElement.repetition_type ==
+                  thrift::FieldRepetitionType::REPEATED) {
+            return std::make_unique<ParquetTypeWithId>(
+                TypeFactory<TypeKind::ARRAY>::create(child->type()),
+                std::move(children),
+                curSchemaIdx,
+                maxSchemaElementIdx,
+                ParquetTypeWithId::kNonLeaf,
+                std::move(name),
+                std::nullopt,
+                std::nullopt,
+                maxRepeat + 1,
+                maxDefine,
+                isOptional,
+                isRepeated);
+          }
+          // Only special case list of map and list of list is handled here,
+          // other generic case is handled with case MAP
+          [[fallthrough]];
+        }
         case thrift::ConvertedType::MAP_KEY_VALUE:
           // If the MAP_KEY_VALUE annotated group's parent is a MAP, it should
           // be the repeated key_value group that directly contains the key and
@@ -337,7 +364,6 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
           // a MAP-annotated group.
           [[fallthrough]];
 
-        case thrift::ConvertedType::LIST:
         case thrift::ConvertedType::MAP: {
           VELOX_CHECK_EQ(children.size(), 1);
           const auto& child = children[0];
diff --git a/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_array_value.parquet b/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_array_value.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..f76b2a89da6186329a15eec86b87e51f5abfe92d
GIT binary patch
literal 43558
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%0D7B+_GWeA5tVa^n%JZ6Z~FCY+~VV
zcM~cxAJEK3pxF{$IjTIr5x-hA?HJWD?LyDATA_c{;gs`8UF1r>lmyY8Y(62hQZM6*
zJ;gTe^PM)X-Z?#QjwTnvf8KKRP(Q?PTO-OXd+W2{c5gS+44&>Iolj8cd)uP#<9t)}
z+RuN?IpT4+Mq^d;{fcf6Wf8jU?WJoQ5g1rbIPP7(r}XHq-RvG;Ry+ILs3d&E{o2mS
z=f*V#y{k`j7h0aT-;QgSv1XNOt+pe%Rzg2kF#o#cya|`$Uh~7qy)4l>YjU19S{dOQ
zf&qSEvESDBXw&;<8wH5MIzCFN)3*p@)jA)|w<K7ieTc|%PunjHenLx*ed~O9M=P(F
z&hxL+kx#OZt3xvaZ9lnjKC2@7@`Hsved)r2b3W|K=h{=-0AfAs{R-MJ3M2Mc-;M8o
z-|)v}Y@>UdM(-2OUhS>>)!!`IWyX@nY;r_}i)lsR^n!9$)(6imqw?fR_@srAOHu>h
z5Pr*Z%>=SHPQ&4bqf3H}Ef4R~e-5aQew;B#u>4QVZS8IDZ}kPWuS#5oK3q2YSd=l*
zUR67|0&{ttVX7;mkooQnf4{|#h~0<`qN|TGZVofD4Ke8D)QvP3%eO_WB9<mMWE5p6
zyyQMRyLg6`y+vsL)5TY6(`xf7gL9-PXiha_g?gCG5k~I+ZKzi`>{7<T#thv(mVuU3
zU6aBeX6l4~Ddk4yuX%-@EeB`EMDG<F+ADoCUTD(Pr+Qwyry0aIdcTolywLDH4a?+7
zIog{Ibi0C|#y{K3GFz4{3qAa<(g%xP7pG9IW$-Lwo@SKUqGQi`jwZwDl#$+YVjb;n
zddp-1&TU&U#8iY>)t~JMk`MRLqxbyD5o9zOaz4|H=$7eZaji(k$34~-(N6F3Eqe<I
znI|qsO|{VqDL32N&p#UU^GmH;l-2n;W$~Q@Z$EfGknG~*#HXn;`!}^!wAX1|jPn~$
zSF5MceDUSh7249g@@+jjIvnob^NG(^I-aUfzy6pi9M`Ohv0_9{+f+w4l(V$u{5{`G
zC*}x#jlBV>bS9lUyBF~@)Oj+Z7)FZuM@r<kP0*=K@H3ZUc&p+(s*-4ZlnrK8y=Frx
z-j_1IFGHs-C8I6F&nu<LE5o)arLyUz5%h_qyHO(Wx<u-GvC#JtrPpPcvZWNVWyI~p
zeC;K2H;TEU?74C5nQ<J1qa38?MKIVz2+BlooJ2?%5y|*Dct&G={D+Q`$HKVj!ZiLO
z*cWyN%n$8pE1Yn$SP}ceOee<7XuAB$%y37tuzG~vj#SnX6aOGVO&@QKCf*BX$|v=7
zmm5evG@#Qp;O94B+cprtX~2{ti{;){L40*&>LCmLDIF3n9nmWtrcOVIUl1Wrb51(Z
zEJl;akt{k850)BICLP7jzCtv?itSOL#{0|%oz~r#QFhapEZc|1(ueA$4}+8s#bY13
ztwZY5C6Z6ejGtD}8CfxN10(pI*>Ky07exvec?y?gE-Z3fSd!S=!MT!}d|kLF;v07t
zb#T8_uog?)4m#5=evwJoqF}5kH?iFD;!n}wpTm}7al3>rL3Q*ay^K`GWSPb^Ph|!$
za4*P}64c!J>7vJc&V=~638us}?2$2D;uOMQit_4WM0-{AclQui_awM`tc5$VWwVBy
zbT78o6eGhF+1)9c^HWrBrx+BbD7-f#7dFE?H=|DwA)$zf;T#O1KquZ{VZ@9umYN7r
z?@|&OBGv?vD1wOh-RTO{?@|wRBnPs)I>LiR=x*nPx8+11Sw%4O50LX~2%khLQCdaa
zfrYGDg=Sh|bHJHlgk)h7R`FM@62HuaB+i8y%q2XWi~2YhdKa%>aC?9;!a?XO3q9Ff
zGNyElwmJ)~NQ?&kGK;c0204pL<cxF#&|ElakvnNg+HjHGaOt=H#i8&GU-bVM{Y7{2
ztcNs7{B~h9Nd5mq`M@~0z$9vJ<um0k?h?P-#Z+?86j59uyj_AFe@m}f^;~n5*!^y7
zFJlIY#kiKL*mniC@pX?(aN(VgRRtM!i`jKc#9w#gUo|29;t-9)9p1<tz2_dI>7Kw@
zuZ3-{&S9=;Ca&f$-9>f|DZRoJ{@rQp^V7s{r~gy>C7(e&q5&9Dzi>hycftT7p<g=C
zUY^sQRbB)?{cp$rOZpuxv<zc=bc_aAJS+mKdgODf1P-e>`{P8HLtGZCaN@a`M^@2a
z<|4-D!hrN|=fZ`z`xPVDFy1sU$<<So%ta!lUxJaW;3X|1l2)(`mnloh!mavP7%|k@
znaRk-jhDomrIUZz-!6pYhFzab`7-%4$oiO;zQiwm|NmGYgR&HlX@{(6hvwoA)w>-A
zr5(op!^n5_i(F&%s)FD3fVkZx_e^kHOi0!ok_oC}bgPJPrArC!m(t!Z!|^DEdz6tB
z7*l^SW+I+~A)Qa~aGG*_ie6xfe8NYCuC){dj)H74n{0{L@0^*RBK&6>_trG&PZ2as
z5xj5_U~^h0Vfc#hFSGA-i|Y>({ipW71IS;5bbpBy8>6@n1Iv*G&Vm=;fTc&4@U(&G
z)LzEIp2NaH;sq<#<@*1bHgV_Y5*6@zFKnwxv(_`=`oL0SdRXWO$msid)Y)(vq@z}(
zL(`?ho3uk|H(;pLQP&3Ar==vAm#bh3Osrr8Os%jAE{WDI^42cNdM|Q%FG)Vz6*}o<
znD1AZAH<Yb$ALUAyre*|LmR}cPPVX!skltBz)B}G6p5a^i)FM+GzsO-GWLaKs?KFP
z;PlQF+}k|~j>kP$tn4E@mV`pnxFes{tI=d=$Yew-@D{W3mWa|X{!03)SQ})ZxV07&
z+fBni8q-}x8r!fc{zg?Y4$AuOaZvDVMoesm)ow<8+6*o9Q4>1QWIE7LIv7MF>SIRv
zoG4mO)1F<^L43fTf1n$4MFgE<DOM*ZfhUK6NxwH>tV@3^jJjhf{?$$|{aC;JShNz{
z2|r6U6pfoK0UNJRm0uNhG9Y>!4s3tUDiK!GZBx^G!?R1XrjOIJU($2X)w7#qTb=uw
zgVa}hrXF9)Xjr5+ecx?*Wh^L8n2B!sBD7%PRt2i!hN{Z)%RV@6sTdMzzO*{VD#-i^
z_t(~-1;)RFa(62l!$E6|UTXqhYux45B)XwKHlR1-q9RKE)t-<+5H^iFltw#5LObMj
zJM=+;iBf^_!5!gboRp<#pG_i24`YlD6PON@>JFoX4)LL6f9eoQwHJMh1DWh3KI&BF
z8WQGO#Ix$ys5fBS80Ve|`MoJb;uP%5G#UsR5c445Io(6E+><KYqrUoR*fxiY*-ha*
zoT6oz!e^L9r8|Yf6odC>qT*&`Cy4gV<lBe@6-0Og0+%$Q$33A-o2c8EsMn{}iFLpU
z0~Ily|I+;|-Eo1_Bb3(JV1)Hp@yL|9Q%}!VPyV2umgSIcw4SotD*6#f8LMRD?H=!c
zozuAlfw?%Zxg>_U*u=RAZRoD{@u;ty1x+cC9xp~s9t6EQMw$;T@2~6Hi@gb@dup8c
ze7B2T_np?rH`;?wTVv^3qdv4o|7eYS0(}#(P$Z{B63KU|tuoX7>$>U(0)MkIUD*YZ
zLK_qqE)*D<d>Ao_ig}I^SUfj2;XB)pCylr2PxI?Q;1mh3$lWd$S9%OQuNE{{#?M>A
z%3F-`d}v-()cYy|u31fnS=C#!YUjn3)uhX)Y|41@N@Q$`IcQ5n^18rTh1UYNyGMWB
z3`yFI^WMaeI#9iGpnm;88S*?3J0VOi$_X#Z5%Jv#4aX6N<Mg-Z!!P9|(c}<Z(GR8O
z?4?MrM+>!z(J<~|BEYg|Tz4W_hq#BLX)zv3b^ZZYEC&Tidp1c2;unq#AZ%3Y$wwP7
z?l{q$bi+OS4I>=sTAXmNIZ^l2Q{VK#Gl@|@3!5K42rVB<E+3-7)DU%T7&9x$u5>Jt
za8e^?j9I8INk=;ubX%7zClXGnB*#mW3W&Exd}xh&(i-;Qko39_4Imr9H&VV3(-6(~
z-U8Y?v(U*vS2S!8#EZ}_L0xJzbs!1FLT^lPN3U&1H!etcZ0-Te;NI)UT}C;(An3`8
z>_e%Z?mQX0*m62-iNRq)0OH-nnD!bs=}mJj31qyB(nH@3=n}?+k4z|tr}2nUJW~}u
z;2ySqrgB7uI}V^4IzTnR_sENiAplvQPGKqP!e*%AX8i5VWOPJCC?bIc5$Av)xemP#
z!1~=*3E{ZF^qf5uGa{H`ONrGW@dF)1E9}W#yGc895`zHMAdyD3MwJ=L`I;_W?t1#s
z9n$q)raK^lSP|f^KA#Ig-qn~}bMb%k3}1@_g`^W9$&zpqGXWIxcv@IrSHNB626xqv
z8J+dlZAB7}b`PYuzjU~BIV&;18T5^kP&l<Oezq^Rr7xirbXqa5?=pR2W;k7zWMm<H
zHKf8Rx`RgQ%k(XU5R-8Qzi^4Ckc|}5ei!4)4*ZC_2RB%qg<yyA-42On&JKRjF80M;
z3IH~)lq=M?%S>e)seh-;pN!vLRiX?b=Z3hG@a3aYlDfObm=Y$0kEXE_r(ua_H<oC8
z8c0kD<c6+mvz8n<u&C22TZ(z36i__f_io~Urs!@>QDX|jev07rict0nBh-Y+KOsUJ
z5RuaeOwxowX;ijDn7N3I`<)&veF*Or*By{%U;K~jddG<;tbyPGSr{sLMv<rWay|Ut
zEFUKf<xls8Z7r;x22vorNlYK|x@r)e(IX2jJ`AGy7!6kQ6d&4+lsIwsl!!Ca>$S!J
z-;;tP3r;J6;0oiXMZuF^ukw|P^IZn>Jy++o;G!w9T7e<a044oW;yva2#pG2K7nX<@
zSW)uR3+*ssgPW_^g~bNl)n&TQ6$-_kFs8GhH@PprOUPHZrnG8?v1ZKp6(D|winY12
zhPf)0c_bUXG0k&8nZ^{Td`AI%lzXCud+fS<sH=MfFn@(l6yfVGs*h8QUegdrGEAeN
zhuogXxEcFtGYVq(&1m3!6$BA*yAM$>z)5!qCqt<_M5q+OY2E2#N0H5d1Am2stSbQY
z5&$yxoUYx}O-s=-Iq^X`q<6Ss5gKzzUUP8*zi@@-Ndqp>`$;{z99bO0Aufm<z6Q!}
z=mLPV0RK?W2pt5ga8RSP>D4Kb?gud6uT#(?0)n3&P<<*9IxBe!9zJh@Ci%o7ziIJ+
zjC+X+t*I|)PQdKMq>$@zultgI+eM@HWuz_+XFOekd$R%ObBd;hYJs4ED4rRxj0U`L
z1^WUkY27ZtQDFFEknIb-SZoU=04Fg4NM77UK_vys^WfLtB#Ckp5`MO3IaPUza=F}G
z83u1DId3m|QdJyp6(-lLhQh2CrnowrxTe=ERA<2zrV!U6Y*yzJ*ANR(zS$hk_qtS~
zU@1&;GsbW;0YaJpEz$rr>HrP!=UgxmbtxaH-3fF6JVT&qPtMuP0AR)ek%SLg6Hz}5
z&^*xqf~dzG*{+~82UG)b=GdU!STFsd8laj6G?3y@eT9x{L?m9Hl2sCwRqSuJ@kYW7
z$QQY5_F^sen39eZFPun0&U5+FgIvc2b(X%zfxg>hdk`IBOjtY=@8nRMT85DV-8Bei
zrK4xGRYfNj32K*VYmqD&Fr^m1-x>l4GyIM(-BxR?ZENVw*5p$k-0Qn&AZ`RNu#rN+
z5*V#D)T7tYqvp&^F}aH|xdUJlfkRmg`|J>buW=Xx9ohOWBuEAik{<U#tu`a&R9UE|
zqh;kXO@^k6G}M;Jc}t=BV9gkwR26o=D)RMT+5_qVs)KicLR>?yS=nD)jSti>yD7NW
zVjRh4%r*Dq+RX&P%?R(!&`+EA;KrU2<pHQo5LBMUJCZB8qZ}~gg&9|b@e6Zee%D%J
zkoYG#$&k%=dI4SvxuS#*h4daU1uYiK0T4X6rG7PC?*LSKc58a}xYi8fAn8)lv;W$*
zGPD?6b0WRQO8Ep9>I1|EhG+F9AN0i-^udev#nSR6n2u2aHI^BUuN{F!WvHf3F1So?
znu<dVXcD@v{>E%HZa#3H)}+hey0#|B9g?D^1F#{G?!agOT0*C_HTg+v^k5(crr$2*
z<PJ!9av=yR!ygX~${`$7(HB-g#6a|32gS}Jo8ppKXEEaG4jtUeq=Hq1RPKoMYZ;bq
zDJ9b8VfRs$R9w|bT;&!383-`76lT>00NqHJ2znHQT1AuBgZ*$R0fY|RJ*mY#TGB`3
zW`MF*fT~-7ie*4AEC9vtns*LRMBnez>VSwU#l7K(rRhki*~{Q0f&(TSXca)<Dvb^B
zANJ6hEujbpA1X~)`Vm~5;MjH%p5%l_f-{Tdhz?;rE8>n5cGe0Lf3I#$&yAXX*$8`L
z3n#)BM=>Pqa9y(pTtlteKzGvzVImy?byj53Q~!WPfo+EE&s2jZF|ovM$b#*bnjj_}
zx}qIMP??H{Up>W4Y*R3ZZP&+PH$b&nJb2Eo_bM{lp^QHUTp9kP6&I6{jT)K^7#CTP
zX&+S?7`71@njM&E8JG<9Rm~iLFW`IO;$h-rWUk{N4=l7C1VP^eSWk5O<aA4#kEw4O
zV?eEyJ6e=G{!ek`EtT~^cGvf)?mC5+IE_U-jpnsTKrIc_M-66WJnf}~$bk$KG}zar
zbnQ-n8S!vRq3sN(m<v^66&8~~z?48l-;akH4fOj0^+V3|oe^db6Q(d*!n}gT3dXSz
z3}kanmci?BJamB88^Q*>ZY$Q){ih(scSy6Guq_;^UN|UNuz~gpzX_CvMWHr>GraNa
z!SRIZ697t5WZ3lj7IZ;*L$6A|3<d*;?$wk<4cYKfIbXiWKcSom1&cqR$=XFx@J%47
zjH}?i0<T@c@dg33Ecj`O1X*CAR3Y_YN(Su-;u<ypI^AOOgL)mxif41#E(sV4z+4c?
z-E)(&3y-36iLev&Rw!%KheuXnog;Tb>#+DcP9on`4SdU7Lenx=IcKh_VXpl5Zi#CM
z8Z7uj7OT*yn^n}r!}w^6!D1;`Fb$>ya=<s^$N|l3n&jg&Is@{?0<^rf`1{6!)0%*e
zhyiHHf`}@Cpb|<Qyx&j>niK_qN)h52Bv(=bu0&o|T<l{JCVye-eHa?Fis?0gl*d!C
zim~S(d<Pb@dW_4cN;MaUgi0`#L3<5Y3%s{`K$V4h?C+hjS2`j*MxD|T%J%^sNPqA~
zDAQxb#Au;rGi1W^&uWL_0H`;&ivW8~SCBgrD%*xsCH;Jep@gyPS38b}Vjg*Mw_1rI
zoJ77caMVayxWZG&!gM7yS_(iV6!i8H_@8&dOhW;tvWxcpTERVT$5Gf%?KMSoWnh!_
zYC0hA_XJV<u!}J~6Hq*An=~OjhkQSviI}#S1qlAW1ho%?p%}YhnpR+%0D>BDTzxdC
z12nln<Q%A52B=*>2%*CPmbYjAULtg(jPwTBhwVYMW6g`uvn@pq=Y-`#_8&y03XY}|
z(SW0@rUPxTFxA4@Y5+3c37TopjUCZ3M8HzK_-h#+FvVKA!r$x24~i4Wc+_^#Pa9zm
zPOK8iA~Q;G;q7k0ZB6cLj&j!)g-d<#Ql(=lq{Beuti-7BgS(1e2_q&0Oar7}LPAY}
zif9@@OE8l`6LGc=*^T+Gt9JbocHJ(2=}n5dwL?8@&a9X?t6-r4F~i;CPq|D(utWKI
z7c1GJ=kh8<mrS4S`}l&pfZCS91Js~Lfi{)1OW4o7q+L^%aZG*au=dZp`eOcf*<haU
zA|t6vh^vb5gX)wrYD^G-ct*u*R_pw1IFKJyS7@H6Eyd0&<3Ji8r`AWsHb5P>S?y+k
zid%pxwABP?NCCV#h@b<)quv1=Cj_#?$`3fw%L|_^^q+DFjP!e)L3Qnb<{J?7Bo{&I
zkM$89LNL#`&W1*C=!6ePz6GJ+EjZB>&SJ#^u*lay&j(Tm)L17>&}0G3fY#K4YOk!6
z4s(%Usr(tEEDhcTFaVRVl7rOml@0-8JXy3A<oGTfu-rH@gPB-cnKdm11H?XmnlBE-
zjnpOmL7-33qExr*K>~c&Q>eyLe*+tRYclQ-Xs@hv)`1c9V7RFaj2a9KdmI=p-_dhf
zevq(3os7T%#0)c}J#KIx*KwZ|2pS-NaQ~I#Fq(dDj?-QS?$EUQy+Z7@p!1-;g5?(%
zD6U~1g-LIM4L12qB+Oq09d;UxcnLMgCuq9Iak@tVp3icRd;ws-9YlNapOq4@{o85G
zf1p`D8Eo=knFpIZI)HhiL1D1hfC7se;5nU8gBeblFs<1l_LW0NPFDw<3TU_|ZW5se
z4@CSIaRJ4LVB<xQgP2!==J=#LD71u_9coh&&^{Am0FCp>#K=wl;asfow(1$)^!Q?M
z`NELPe3G{M5+w;V&i6xc4-LafsEG_{578vj_mJSg@JRh3rpK4^C4B6Qd^iG%6O=p1
zWCxOh7%>S^rCh=<T&DSJzVwF{g+*wYL?P$Dw_y~__hRs^-sz}>phmYB>;`bCNmYda
z$B+0ZL-B$VA9^5SLI@s(jQ_O{L-iGzFt(7<e?d*NsuY0C_A=ZXJ!jqZ=M+<~Fg<9n
z;ZS#_{Oj=&SSi721Z8LCY?X}svtWYz33V*1*h^NC&+)pE^JNdTQ9^X%2(1n2FlZ%)
zw){g}x_YwwdK%k$syDFEzt;okX~+*>v_CBWm(!uAB4qK>eQIF@&{8=8Hk+wMXdM=t
zT9$_nD|BC1P-G9zE2=sv&3B)lSK~xY2ZBU_30$bh9^hLbFgALqi?2hIabZzlZx>n%
zP(wVb#X>kKcN=W++#uq2=q!d#eJua$LqOD_Rl7Q?3HV*0wfHy0K;!&G6@-wszp51g
zd%0#U+yHg108LPw&LZZ<ug8Ko_8{KDLqL%5|Lq|l6f|I}>4u1MD<?EJ2m9h!6w`Va
z6GS#8%4iu@A<F!HtXK}<*B$UcLG$-RKzjkeHb|BP-3e8qxKzoa{+WwL&hik&vx8aQ
zHzpd53>h`ZjE5HaNcX;9B+rIF3=Q-uyw6Y%pxRF#Y%-RjO{b!veVS|Wdh_?+Vz#Ho
zb*Xl8gW^BtCecY6Grj0nq`9Prc?|udnhI9rsauCQ1pOn`?AC;}q(>xb{loL;mnE;a
zjw*cG4~dpv7BLDO5i8se%kEf~xN_KI*}0o_y<-ED>8Q`Gb3Ys{bzFKW7FdEThZ&0l
z(S5XaB6NE{8g_#PU&FlzmgRGN^(6UJ@iboDxfGV^uFfSX5~Bm|Rd!$>7dpO<x?@^O
z29Yy6MeeYwMOy0dQw{ENcB*O}HJfLtg`Un_xH7{U-g_z8!IZ_!k=*)Zai$5!l$BT<
z;D2a4vF$O<iZd@2J;$vT#A}@CVP1(NQLW+i-Z=ZlY$ZDJC3UB~sSH=~N^F5k8kb*B
zWnF8o#AMh~cWa-@^bV-RRoK$F@_j1%_JJE3CQYAxlyG$0n3E!*)evixXhJ`~1J5X8
z!m~o;F3p%Tyo{#TYCxnAU*DNLJ-5ePQ#j3}#!=$3)u?P%Q&?t=8z$YW9*dTSy9}O=
zVsfwgy$ze9|0!@}`XSS$LgJglM!$v_l<C%)@X7Ko*ubD}>vO5~$-Hd0fg{z{@Ab(i
z`{w)xI%!a!Q{hgAoBRg$mB3NCh5gXv;AOFkfx~<kDEQ-K;CFWOm5$e#PH#P<2?+^4
zhf9u05m6jG^J9WE?136A%{YRS$N^s~kQJ7yt<EWH5~C~b2uru><0SEo)e0t0Nl|C#
z#MjZ$^fOIKGcV^PzNDiC{y@J}eP>R>wjl$H#?-s?tL&sf!&<iqj8jx8EATXUG<|iA
z(@Zleh+KFefm3zOD+tb2YhLv*PPdt@Ah}wtb&GZ?MN_;2-{6v_zs*#dMRNtQ*Cnl+
zvQw#s0r%+MZmAgEn9f%Ws35$B6gb0y$PJ5)MnmblSV(As8wN#gpL2z9<|TbM9I@Q~
zV0eAXt1$<0C&Z}qx@fWnzbn3;^?;v6ecHJiSK`aogEu7WQw=;_`QFS;kX&nwf4l7<
zWIH!_o5Uxj4C&}Tha{ggvw}7Hjkc~!6F#YWcIyO|Z39=mebQ~`*GaCo4c=nhNzsyD
z$2STZ@V~H=CIvY<Xz-@uPO4GxI^o5m0n*!h@$Zh8gx(zu-eLNJ!^|8SqZ#l&bYw5V
zGeGo^C+(;+v+8K;il$M-4ym*7hT^LlhmjS)%2@=qv{iIXQ}Yg-nb~rO^x=(ZiQB8p
zTtH~Xy|m=xKVDwWC}zJ`rS5VcW#4-|YStqrg#_m1lEBFf?@g1xix;yby6aQqJxf>*
zD5to)rE1weeHY$bPWAATn(gc9LXv}Gu75TSn7%(tJ|VJa4o8f^fPHz0+<0elCWu@`
z!&1i_DVu1<5d)%0yZZL5={aNc>!L;2V@@pbR%7H@jR|Wt_8bqa#%W(PCVla=XUm@(
zgSRv$e%!X_dNMc8__Z<lC;cLGwDcHRl3&6~!6JL5^f=9gU(&waB5QW*7*(xb;)nS~
zPSVzXHOAeXH}gw^-&!Xr3ilGIJ65Ucf_iNib_+LxS1Fhd$EZ8^5<ed=ay>m9XFAyf
zsjx+&tc(f{{v|vkELL))j?;LWKB_23Poo0DxsRE%A;y4ynLPQBotb4=2dS=jIS0em
zu(GCTYA(MshtScGkz`|fc)=>GR1mka3V}(6BW0zq2Dge1t#M>yMwvWSl{N?OOv-)p
zGFgc#9RUxsXkczZmnvZ6=^Re+do<&hRP=17^CX+^F?`(8=8~O>tPLo`JhO4<K^f^!
znl5D=ksKBx7ep^jx3;E8o=AcV{Yq|^I;Ti3kG>1-Om4U5x^TMnm<!{+b(bo<A%}zC
zg=W;cTi2o?Pol<!;lrygP05B_0Z$jYH?O)4uQlW=Y`ZYw%0S-D074^k!q7KQ3}s^t
zLEl_HyEWREZQTamzWH+VYmDE5x*(ys<kx5>gSz!D?B+>ztTB8(>H@)h7a19cqe>?~
z5|q%CR+WzWubjY)m0+Q<zr@30(a~llPmd^PXOsEM#;Gy-l%?c}P=rs%s^~kC6>OI?
zb5v^^&^}8``pd>3B&gel)h_I%7GY49!y<W9P2x-n$TP|*e|s0Gi!yB9Y^mhcDm?{W
zv&j3XK-S=$&RTCS=6L9CKnHpEkE0n6%Bla^QoHzlx(J=f85T~{V;m(?03`z(VwhV~
zEUF>FNuDBSh@Dd`vKj<(Q*N)_x=0Z=zcX39HMj!}1ynW8R1d6sZ6q6G$7`Gv=;ly?
zyzNZ=<W;Xpl5fF3+fGWj(nBmH{t@wZ%c7R8BNB#CUaS+j$qWVw?)<rR{&(r-SK*J_
zde49IEg}WpEjohE-rX*dvF5{c=DlJpHfff?lGC({9m`U8fZP}MqaGhWu35QzSctY4
zg2f62geWSB2~1-DB#4fo{Bn9o1UoB{gN{CV8c2}eB4_@6>{ct$u>a)q+1-P(Vy#+P
zgV!YYER?D4n<l=WE#`bwW$-I21pZt-q{z>bz6KPt-QCouZhw~e>Az;hQi45u8RGAN
zpsWy0+#0jzY|0r2S&@9iZ_o0}!u*aRdR8N%f3m{+Ykl@DPlsQj{NJ+zvM>l`$jwkz
zJZ>Fl_~e)TLw;2uIdF^u#BZhi3M8`sSwMUa>>|9d7x%JbN#N<B!BCEC?$oi#DL8%t
zTli{L7_cOuv9JoBu5cJd7!<;1?%n(o6VB{h*gQHK9+2E1k7Kog+-a!+<y@G*^SD^t
zg<DT%#4I%K-$wpL9N<mJtkVB48vn}UUq*hGMABRdX$;&8C5D{BrjF2!ndrarc<C?q
z>O0Ab<qY$?iv8jZJWbKK=>!LUD33ul5PLfFj9N_)w4e^3t@Wtvi>CjY$Nm{k|7#xq
z)_9Qx(ztN%H?$S*7Mw-%Sss(#0oN|R6$6%{jKztkf)CPnXXfq2W6p9}$`YV=4_Ur+
z9|t2ud8}l)+<jcU_}U;tDAKLe*<?kuRZY`U3n>3k+b^0!A;tfm7H3GozgDGs?!L)g
z+SzjWqiVJD?@fwu#LLMNFR7a4O&9#Sbf_$r`{-_jEBh?=zo!LRf-~iRfZ7?pHRVo1
zM*c5p0hsM765sk<Tk10zP-$`DtA9v1{W65ZB1uijW{}7-z19=Hg?}@f-J&9C;Luq@
zlO>~&!m?wX81V9Md^;SG0+0;CA@FnMArdW4@fP`+L-F)sJ+KUWEG{gFlR@%sMsU#o
zR`}o7PTLR}*yU^rG(*~)qUn(}&TQB`!-gb&X>qf_+%DX|vBHH%-675x96m1UHXaon
zU6Z6e^J3QjwDGeL0LZ_w;*X7!0!qcsZ|VYmi(fb>5&F5QdHu#z`oC=ae?~=P+PO1=
zhBrmr<9Cwbo9n&swV~*Fje`KL72r3Y6g5w0iu^NHhQyZnU$J5@B-(C8R;qPaz}r9i
z$^42U%Er*OLmfUc;iOy+kOCt{KQCgXKc#rLpRW|W$W{dMSaJWI>I7PF>YX*ZcSkB#
zKYb#&FvwzmH4q$;SdCwR;TvOMx15@zjw~Z*PX0v|Q5of|5>PJzPPSX+B-I$wQ`|EP
z38O3(M#6DQIz516P({v|jXbj&>0}6w0brn<Tq<JVuB(T1aw#$KB?BQ@WD$W#PU|d^
ze{LE<MFgG572q54?xCDK7|1Cc)o@lh&YbL@3nKYncQ3QXp6(4QTkme$L&r|>t6$+G
z<Ov+&lx&J@DsbY{f^_yRpeR@suaxfPwP=b`+ulIKZR<G)>fU8=?0}QmK>HX(a`L3Y
zpNxR;?XMHabi7I(x_m<j51{U@(dpC34)jBT)8301_robdW7JtiP4HB-Rmt*%BRJ%j
zkkJs9!OkUn1`<{3Y%Cy(an9<Wh_;cZBYAv+Gpm^OknV4I8$xxE)q4Qmbn$gf<DO-d
z@UL+jVe^{Cj+mDq`m1#%?wci}I*1V_?Xwt=9T2>k**uGT(Oe<`QUX-J(20N&kjlDJ
zH>U0u9+XPm+SG%JhYFFiuo_~(2kLM{F37eqAQl>{?<i`PGa_Cg7M?riDCwUwD!<+o
z5_xv+kR{I%6X1pHi^jrnPX|EBy`b-<14;&pk1C=90}(CLW0K?_HdC+!e=O5)FyRLo
z7pfyrN~EJWj_R*gePO5IF^ZCJF6<)v-aDvZ?}ry1qrd`mT!xUpjvbKoEG3}ACknMZ
zaN$79lLf6BJp9N8Y$1ZIB<W$0doO7lp%bKK1yJ5Y^baeu5ST@bIkWI_aO?1hrp0<f
z)o$46nqNvfWN*;@kk`<>l=gWwboavBLHYPnWyD516Oo0&V*?M9d|9CI!%G@+uV+Hf
z0z;~OCLB^&ZA<G8&Qx?K3gFnI#KKY&93h2;IfX&_aOMTw87K_!*p<XTcaR7aK8-Oq
zBv7CfMmFjfO`(aPM%&JfNVYVE-`#eUx;Y0a98reqAtHu;aWnKASZ>mzG86uxXDp`x
zYV;5JMUcZiYPG&7fII5?gU3T$iu=fNeR_B?*ngb*==$xQ^ozl3bWe|fd)w(^y0BQd
zyYZj`owXRj%nlA8H!E2x)a#~W4E4c7j=4S-!QB`mR`RqQc6Mf-VQoVK)3iKf3DMDT
zMRsX6LTf0NQ`6^HS)e|GPGFJ~Mp?q$&uxgWYm&Ez^sx@)<G-;DRjVN%4~UoWjJq2W
z{_!z%?SPN@-fkL_;s~dxfaVcSql#>M5HZt?N)Lz?oE<(aPSMy)`mO|KxuE!o<mZk#
z2<}^f5+YKBTr;2mu221i$ysO8zCspgg<pdE$Mk|O4GteZq;kO$|AzD=wxD0^2apj`
zsJ3@j@h}<pVgN^+twTsw`y4o_rMMGb1nm~c!v`Harc*upPx#8r7+|h|xEXKw;y1N;
z2V~vL@`+%DH$cHm5ec#ZM?}X62N)Cb=n?4E&{V<BC9$QgX0w+9L}wLxHLM~Dg~uu<
zSDUu7>ayA2*#PPu7RN9U-87~Lh<?`b-p}4s{Nk>Rtk~k^P#TLtQ-ye?gqORzZTlG@
zZ>dv*Uj09~VnjGf7%A@xV$yv;I14oZjZm%&X9od}1At8A+870hP2hvoBvhusK7pK&
z;7w2=A$(xn|J%f`1{uFLWl|KZg9eR+2|~M7WUnUi$#A0I;C$TH&j8gusN=OEcQ{=6
zRp94dTM*3G<yScB0w)MB>=)JrugEDK4&y5B#ZCsZD68%pLfT&Z{uG~w6iLKN-|yga
zoN}EQ5g}I!ya+B@lUPF{M{<C1tgK)TVrQj@1U;GzA1Wbf39G0Q0?k1IAc|iNsaiZs
z$tqZ7mIL`K5|<v2tarl(j3dTLd#fBwM?A{bkg<QyL7`xUgGz|P`<aj^@lp{``oLgO
z02eQ#5&(Of%}f%g)Cvrn+JBXhi{GcfVBrX+H{@V}Dk0FtOVvqmC34CgqeP|y=+U`<
zQu$wlh0Tll|1ns+>W2mkH4qd({!JEwexcCTi5e`@A&k4;Hi`MkHy*edvalX>@qpZQ
zf#Y-wdr9Adm-yZtP9WzXBvXtb2MdlpK^QV9&>={MMb$^J$wT~x8ZIzE)dLenexN!R
zSSwVZrOg@16_Cm?sL{<xwlO8Q20069c>ASAcQ~^_dS3H020>AZ2kn|8##w$Dl^9gj
z&@5Cy4x;<-(e08UP&q8Cxm1A|D$&o9G?Av(G((PV6@+J7P%5Z;Wm}WnP-dVe3i|=!
zuunvld~cD6k*cHb%4?Q05a24DE(5I<x&5Ay;9zuvx`#z$+;e^xDQMt4i(|RDVL?F1
zUY>5GH(w2&trft&17K-`xPo#+dNc@H+Www}kfR$|+F}OfmmpX+E8I<k2>IWm8#0NH
z*O~4d>V@>V-aRFYVaDPFS!{@>N*)JYyb^pPtWt7l*M$CumH>bZAdAtFyJlKUA3F=r
z@Q|`*+OLbJC;KcN8iXjo+=gNbki|U8if6Ha%wkg@aVhA3MjT+*w3#gzeO_fq3`V%u
zvn7Jy;{D%Qd<&d85Efvk;O<3$SO$a8K`Ga*&2c<Uu{4te2UaH<$jGrgKw{Jg7Y_w+
zQ|@3e9E{9hviK!2;9|PDAs}%qU<#;03tod_c?nNTX22JW6JiC+;y`U^;#8wwM-9h*
z0O&U8U$#yVd;3A|h2}Oj#{C#v`6Zsopn+e#8DudkAs{1n8+GoZ%E#eF@+)ZQ`0Dmy
zzuO0x-5^{8T=6#`dxDr{XXjMJkI_;kPt90m2bBZ#X%GxhiKZD=cWq4hADhLm_JJDc
z|7GM%um*wI%>YTovn4Fg-8CVus1UE@5O4?c{IjTk&GT+xVCylyAsmJxw^1}4(U|Uo
zG9@;eesfpkI)R*kz#0TKXOPa&@e3MrLnpNEbIhvGaN&2u=Ckhicu}8)>UTW=g(3Ii
zf_Wab$-A6!MF<FAtV-!&DnWm!--$z9QR@eB1qqP$ythw${`~si^Sn?{|K)|9tm_~c
zK0^;dcJdc>#syi99-Q<lg;kwup<$56bOm4iirhL?zTAoJ?h}q+75}}?Lqwtf*QzWE
ztP9PWsF4D>&gW`t*?>4c0PDQ<uqIULptTKLKSRINeEC%_p(8*PaVBYij4A)Wtn*;j
z1XcRiIv-y6XL!4CP(cbA8b=tc^A6H%G~K_~HpCD!ju;da(5$HshI)wGMxhKA%?46~
z{kRJvig6%yzE!^m*ejrgQ*Le?%$j!}dOATtaht>s5XIszL;qgeey#KU&^mwlU+X;2
zB)D^hJO5`;jGm?i;o@mShwl_qn62)XS|=JB4H*Uv0$rE}fhi*+Lxn*DKOjYY3=0kX
zMT5Y?=0Zb*KAxt8MnezBqk1uc0f+t#J$zvTgX&-!`A^^n1ZxwzU%KXU(cj74#mj*T
z15E-0ffeB5A3%jcg`+PIeu@MZ0^7mQ&mjnW1Vf)6^%4BbE<qQsIe1=mp~9lVLZc$$
zKto`Hk8z;s(?dT31A&eDx4%9M6$Zzz&w~cfg458`@N?qPQxVZ{pyAMHBflc*tNi)Q
z(C4GVf=4Bx!&}Pm;NTT-;>k-Mka9z>8N7J#V!&^}3SK1|8vK3<HWdQ?tQeb$8;ujZ
zLVEDhpwDdeUq3VIzwPW*VZp&~+6wPF!iED?pr0#`QV)TY5(vnR6chE2e}By$@HOe-
z-@(@uMuUGXAOSCn6AwO8j7^D##;xn);OBeQB|yN-kNKL5pZ}#R-pnF`BBFw#%-oJw
zFL^pMOG&wi2|Gy(%ZQ0dOS(8oh&qWmxjINXiHSQ(xwwjniHeAciaN=N^U&}ENg-A1
M(9zJ0RZK<xAF(1+oB#j-

literal 0
HcmV?d00001

diff --git a/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_struct_value.parquet b/velox/dwio/parquet/tests/examples/array_of_map_of_int_key_struct_value.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..3eb637958290fe0f60eb7af9c9fd33a12cd3a25b
GIT binary patch
literal 57932
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

literal 0
HcmV?d00001

diff --git a/velox/dwio/parquet/tests/examples/struct_of_array_of_array.parquet b/velox/dwio/parquet/tests/examples/struct_of_array_of_array.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2b161e77d773e2a6469a1e5fc22cbfe919793336
GIT binary patch
literal 86749
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

literal 0
HcmV?d00001

diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
index e46dfadfa1ef4..b3a5ea7ade89c 100644
--- a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
@@ -1235,6 +1235,155 @@ TEST_F(ParquetReaderTest, testV2PageWithZeroMaxDefRep) {
       outputRowType, *rowReader, expected, *leafPool_);
 }
 
+TEST_F(ParquetReaderTest, arrayOfMapOfIntKeyArrayValue) {
+  //  The Schema is of type
+  //  message hive_schema {
+  //    optional group test (LIST) {
+  //      repeated group array (MAP) {
+  //        repeated group key_value (MAP_KEY_VALUE) {
+  //          required binary key (UTF8);
+  //          optional group value (LIST) {
+  //            repeated int32 array;
+  //          }
+  //        }
+  //      }
+  //    }
+  //  }
+  const std::string expectedVeloxType =
+      "ROW<test:ARRAY<MAP<VARCHAR,ARRAY<INTEGER>>>>";
+  const std::string sample(
+      getExampleFilePath("array_of_map_of_int_key_array_value.parquet"));
+  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
+  auto numRows = reader->numberOfRows();
+  auto type = reader->typeWithId();
+  RowReaderOptions rowReaderOpts;
+  auto rowType = ROW({"test"}, {ARRAY(MAP(VARCHAR(), ARRAY(INTEGER())))});
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto result = BaseVector::create(rowType, 10, leafPool_.get());
+  constexpr int kBatchSize = 1000;
+  while (rowReader->next(kBatchSize, result)) {
+  }
+}
+
+TEST_F(ParquetReaderTest, arrayOfMapOfIntKeyStructValue) {
+  //  The Schema is of type
+  //   message hive_schema {
+  //    optional group test (LIST) {
+  //      repeated group array (MAP) {
+  //        repeated group key_value (MAP_KEY_VALUE) {
+  //          required int32 key;
+  //          optional group value {
+  //            optional binary stringfield (UTF8);
+  //            optional int64 longfield;
+  //          }
+  //        }
+  //      }
+  //    }
+  //  }
+  const std::string expectedVeloxType =
+      "ROW<test:ARRAY<MAP<INTEGER,ROW<stringfield:VARCHAR,longfield:BIGINT>>>>";
+  const std::string sample(
+      getExampleFilePath("array_of_map_of_int_key_struct_value.parquet"));
+  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
+  auto numRows = reader->numberOfRows();
+  auto type = reader->typeWithId();
+  RowReaderOptions rowReaderOpts;
+  auto rowType = reader->rowType();
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto result = BaseVector::create(rowType, 10, leafPool_.get());
+  constexpr int kBatchSize = 1000;
+  while (rowReader->next(kBatchSize, result)) {
+  }
+}
+
+TEST_F(ParquetReaderTest, struct_of_array_of_array) {
+  //  The Schema is of type
+  //  message hive_schema {
+  //    optional group test {
+  //      optional group stringarrayfield (LIST) {
+  //        repeated group array (LIST) {
+  //          repeated binary array (UTF8);
+  //        }
+  //      }
+  //      optional group intarrayfield (LIST) {
+  //        repeated group array (LIST) {
+  //          repeated int32 array;
+  //        }
+  //      }
+  //    }
+  //  }
+  const std::string expectedVeloxType =
+      "ROW<test:ROW<stringarrayfield:ARRAY<ARRAY<VARCHAR>>,intarrayfield:ARRAY<ARRAY<INTEGER>>>>";
+  const std::string sample(
+      getExampleFilePath("struct_of_array_of_array.parquet"));
+  facebook::velox::dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReader(sample, readerOptions);
+  auto numRows = reader->numberOfRows();
+  auto type = reader->typeWithId();
+  EXPECT_EQ(type->size(), 1ULL);
+  EXPECT_EQ(reader->rowType()->toString(), expectedVeloxType);
+
+  auto test_column = type->childAt(0);
+  EXPECT_EQ(test_column->type()->kind(), TypeKind::ROW);
+  EXPECT_EQ(type->childByName("test"), test_column);
+
+  // test_column has 2 children
+  EXPECT_EQ(test_column->size(), 2ULL);
+  // explore 1st child of test_column
+  auto stringarrayfield_column = test_column->childAt(0);
+  EXPECT_EQ(stringarrayfield_column->type()->kind(), TypeKind::ARRAY);
+
+  // stringarrayfield_column column has 1 child
+  EXPECT_EQ(stringarrayfield_column->size(), 1ULL);
+  // explore 1st child of stringarrayfield_column
+  auto array_column = stringarrayfield_column->childAt(0);
+  EXPECT_EQ(array_column->type()->kind(), TypeKind::ARRAY);
+
+  // array_column column has 1 child
+  EXPECT_EQ(array_column->size(), 1ULL);
+  // explore 1st child of array_column
+  auto array_leaf_column = array_column->childAt(0);
+  EXPECT_EQ(array_leaf_column->type()->kind(), TypeKind::VARCHAR);
+
+  // explore 2nd child of test_column
+  auto intarrayfield_column = test_column->childAt(1);
+  EXPECT_EQ(intarrayfield_column->type()->kind(), TypeKind::ARRAY);
+  EXPECT_EQ(test_column->childByName("intarrayfield"), intarrayfield_column);
+
+  // intarrayfield_column column has 1 child
+  EXPECT_EQ(intarrayfield_column->size(), 1ULL);
+  // explore 1st child of intarrayfield_column
+  auto array_column_for_intarrayfield = intarrayfield_column->childAt(0);
+  EXPECT_EQ(array_column_for_intarrayfield->type()->kind(), TypeKind::ARRAY);
+
+  // array_column_for_intarrayfield column has 1 child
+  EXPECT_EQ(array_column_for_intarrayfield->size(), 1ULL);
+  // explore 1st child
+  auto array_leaf_column_for_intarrayfield =
+      array_column_for_intarrayfield->childAt(0);
+  EXPECT_EQ(
+      array_leaf_column_for_intarrayfield->type()->kind(), TypeKind::INTEGER);
+
+  RowReaderOptions rowReaderOpts;
+  auto rowType =
+      ROW({"test"},
+          {ROW(
+              {"stringarrayfield", "intarrayfield"},
+              {ARRAY(ARRAY(VARCHAR())), ARRAY(ARRAY(INTEGER()))})});
+  rowReaderOpts.setScanSpec(makeScanSpec(rowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  auto result = BaseVector::create(rowType, 10, leafPool_.get());
+  constexpr int kBatchSize = 1000;
+  while (rowReader->next(kBatchSize, result)) {
+  }
+}
+
 TEST_F(ParquetReaderTest, testLzoDataPage) {
   const std::string sample(getExampleFilePath("lzo.parquet"));
 

From f369a2653d5bfd3460afcf0243bda2d98a72489b Mon Sep 17 00:00:00 2001
From: Chengcheng Jin <chengcheng.jin@intel.com>
Date: Wed, 21 Aug 2024 11:32:01 -0700
Subject: [PATCH 04/24] Fix spill time metric unit (#10783)

Summary:
Change the spill time metric from microseconds to nanosecond.
This is a follow up of https://github.com/facebookincubator/velox/pull/9765/

Resolves: https://github.com/facebookincubator/velox/issues/10688

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10783

Reviewed By: bikramSingh91

Differential Revision: D61582818

Pulled By: xiaoxmeng

fbshipit-source-id: 59a7d0033a3ce1790c90498306c599a4f17f55a4
---
 velox/common/base/SpillStats.cpp              | 180 +++++++++---------
 velox/common/base/SpillStats.h                |  30 +--
 velox/common/base/tests/SpillStatsTest.cpp    |  76 ++++----
 velox/common/time/Timer.h                     |  18 ++
 .../hive/tests/HiveDataSinkTest.cpp           |  12 +-
 velox/exec/HashProbe.cpp                      |   2 +-
 velox/exec/Operator.cpp                       |  51 ++---
 velox/exec/SpillFile.cpp                      |  47 ++---
 velox/exec/Spiller.cpp                        |  30 +--
 velox/exec/tests/SpillTest.cpp                |  56 +++---
 velox/exec/tests/SpillerTest.cpp              | 100 +++++-----
 11 files changed, 303 insertions(+), 299 deletions(-)

diff --git a/velox/common/base/SpillStats.cpp b/velox/common/base/SpillStats.cpp
index 4056f5c411630..a6a3dae5f9d2c 100644
--- a/velox/common/base/SpillStats.cpp
+++ b/velox/common/base/SpillStats.cpp
@@ -42,34 +42,34 @@ SpillStats::SpillStats(
     uint64_t _spilledRows,
     uint32_t _spilledPartitions,
     uint64_t _spilledFiles,
-    uint64_t _spillFillTimeUs,
-    uint64_t _spillSortTimeUs,
-    uint64_t _spillSerializationTimeUs,
+    uint64_t _spillFillTimeNanos,
+    uint64_t _spillSortTimeNanos,
+    uint64_t _spillSerializationTimeNanos,
     uint64_t _spillWrites,
-    uint64_t _spillFlushTimeUs,
-    uint64_t _spillWriteTimeUs,
+    uint64_t _spillFlushTimeNanos,
+    uint64_t _spillWriteTimeNanos,
     uint64_t _spillMaxLevelExceededCount,
     uint64_t _spillReadBytes,
     uint64_t _spillReads,
-    uint64_t _spillReadTimeUs,
-    uint64_t _spillDeserializationTimeUs)
+    uint64_t _spillReadTimeNanos,
+    uint64_t _spillDeserializationTimeNanos)
     : spillRuns(_spillRuns),
       spilledInputBytes(_spilledInputBytes),
       spilledBytes(_spilledBytes),
       spilledRows(_spilledRows),
       spilledPartitions(_spilledPartitions),
       spilledFiles(_spilledFiles),
-      spillFillTimeUs(_spillFillTimeUs),
-      spillSortTimeUs(_spillSortTimeUs),
-      spillSerializationTimeUs(_spillSerializationTimeUs),
+      spillFillTimeNanos(_spillFillTimeNanos),
+      spillSortTimeNanos(_spillSortTimeNanos),
+      spillSerializationTimeNanos(_spillSerializationTimeNanos),
       spillWrites(_spillWrites),
-      spillFlushTimeUs(_spillFlushTimeUs),
-      spillWriteTimeUs(_spillWriteTimeUs),
+      spillFlushTimeNanos(_spillFlushTimeNanos),
+      spillWriteTimeNanos(_spillWriteTimeNanos),
       spillMaxLevelExceededCount(_spillMaxLevelExceededCount),
       spillReadBytes(_spillReadBytes),
       spillReads(_spillReads),
-      spillReadTimeUs(_spillReadTimeUs),
-      spillDeserializationTimeUs(_spillDeserializationTimeUs) {}
+      spillReadTimeNanos(_spillReadTimeNanos),
+      spillDeserializationTimeNanos(_spillDeserializationTimeNanos) {}
 
 SpillStats& SpillStats::operator+=(const SpillStats& other) {
   spillRuns += other.spillRuns;
@@ -78,17 +78,17 @@ SpillStats& SpillStats::operator+=(const SpillStats& other) {
   spilledRows += other.spilledRows;
   spilledPartitions += other.spilledPartitions;
   spilledFiles += other.spilledFiles;
-  spillFillTimeUs += other.spillFillTimeUs;
-  spillSortTimeUs += other.spillSortTimeUs;
-  spillSerializationTimeUs += other.spillSerializationTimeUs;
+  spillFillTimeNanos += other.spillFillTimeNanos;
+  spillSortTimeNanos += other.spillSortTimeNanos;
+  spillSerializationTimeNanos += other.spillSerializationTimeNanos;
   spillWrites += other.spillWrites;
-  spillFlushTimeUs += other.spillFlushTimeUs;
-  spillWriteTimeUs += other.spillWriteTimeUs;
+  spillFlushTimeNanos += other.spillFlushTimeNanos;
+  spillWriteTimeNanos += other.spillWriteTimeNanos;
   spillMaxLevelExceededCount += other.spillMaxLevelExceededCount;
   spillReadBytes += other.spillReadBytes;
   spillReads += other.spillReads;
-  spillReadTimeUs += other.spillReadTimeUs;
-  spillDeserializationTimeUs += other.spillDeserializationTimeUs;
+  spillReadTimeNanos += other.spillReadTimeNanos;
+  spillDeserializationTimeNanos += other.spillDeserializationTimeNanos;
   return *this;
 }
 
@@ -100,20 +100,20 @@ SpillStats SpillStats::operator-(const SpillStats& other) const {
   result.spilledRows = spilledRows - other.spilledRows;
   result.spilledPartitions = spilledPartitions - other.spilledPartitions;
   result.spilledFiles = spilledFiles - other.spilledFiles;
-  result.spillFillTimeUs = spillFillTimeUs - other.spillFillTimeUs;
-  result.spillSortTimeUs = spillSortTimeUs - other.spillSortTimeUs;
-  result.spillSerializationTimeUs =
-      spillSerializationTimeUs - other.spillSerializationTimeUs;
+  result.spillFillTimeNanos = spillFillTimeNanos - other.spillFillTimeNanos;
+  result.spillSortTimeNanos = spillSortTimeNanos - other.spillSortTimeNanos;
+  result.spillSerializationTimeNanos =
+      spillSerializationTimeNanos - other.spillSerializationTimeNanos;
   result.spillWrites = spillWrites - other.spillWrites;
-  result.spillFlushTimeUs = spillFlushTimeUs - other.spillFlushTimeUs;
-  result.spillWriteTimeUs = spillWriteTimeUs - other.spillWriteTimeUs;
+  result.spillFlushTimeNanos = spillFlushTimeNanos - other.spillFlushTimeNanos;
+  result.spillWriteTimeNanos = spillWriteTimeNanos - other.spillWriteTimeNanos;
   result.spillMaxLevelExceededCount =
       spillMaxLevelExceededCount - other.spillMaxLevelExceededCount;
   result.spillReadBytes = spillReadBytes - other.spillReadBytes;
   result.spillReads = spillReads - other.spillReads;
-  result.spillReadTimeUs = spillReadTimeUs - other.spillReadTimeUs;
-  result.spillDeserializationTimeUs =
-      spillDeserializationTimeUs - other.spillDeserializationTimeUs;
+  result.spillReadTimeNanos = spillReadTimeNanos - other.spillReadTimeNanos;
+  result.spillDeserializationTimeNanos =
+      spillDeserializationTimeNanos - other.spillDeserializationTimeNanos;
   return result;
 }
 
@@ -135,17 +135,17 @@ bool SpillStats::operator<(const SpillStats& other) const {
   UPDATE_COUNTER(spilledRows);
   UPDATE_COUNTER(spilledPartitions);
   UPDATE_COUNTER(spilledFiles);
-  UPDATE_COUNTER(spillFillTimeUs);
-  UPDATE_COUNTER(spillSortTimeUs);
-  UPDATE_COUNTER(spillSerializationTimeUs);
+  UPDATE_COUNTER(spillFillTimeNanos);
+  UPDATE_COUNTER(spillSortTimeNanos);
+  UPDATE_COUNTER(spillSerializationTimeNanos);
   UPDATE_COUNTER(spillWrites);
-  UPDATE_COUNTER(spillFlushTimeUs);
-  UPDATE_COUNTER(spillWriteTimeUs);
+  UPDATE_COUNTER(spillFlushTimeNanos);
+  UPDATE_COUNTER(spillWriteTimeNanos);
   UPDATE_COUNTER(spillMaxLevelExceededCount);
   UPDATE_COUNTER(spillReadBytes);
   UPDATE_COUNTER(spillReads);
-  UPDATE_COUNTER(spillReadTimeUs);
-  UPDATE_COUNTER(spillDeserializationTimeUs);
+  UPDATE_COUNTER(spillReadTimeNanos);
+  UPDATE_COUNTER(spillDeserializationTimeNanos);
 #undef UPDATE_COUNTER
   VELOX_CHECK(
       !((gtCount > 0) && (ltCount > 0)),
@@ -175,17 +175,17 @@ bool SpillStats::operator==(const SpillStats& other) const {
              spilledRows,
              spilledPartitions,
              spilledFiles,
-             spillFillTimeUs,
-             spillSortTimeUs,
-             spillSerializationTimeUs,
+             spillFillTimeNanos,
+             spillSortTimeNanos,
+             spillSerializationTimeNanos,
              spillWrites,
-             spillFlushTimeUs,
-             spillWriteTimeUs,
+             spillFlushTimeNanos,
+             spillWriteTimeNanos,
              spillMaxLevelExceededCount,
              spillReadBytes,
              spillReads,
-             spillReadTimeUs,
-             spillDeserializationTimeUs) ==
+             spillReadTimeNanos,
+             spillDeserializationTimeNanos) ==
       std::tie(
              other.spillRuns,
              other.spilledInputBytes,
@@ -193,17 +193,17 @@ bool SpillStats::operator==(const SpillStats& other) const {
              other.spilledRows,
              other.spilledPartitions,
              other.spilledFiles,
-             other.spillFillTimeUs,
-             other.spillSortTimeUs,
-             other.spillSerializationTimeUs,
+             other.spillFillTimeNanos,
+             other.spillSortTimeNanos,
+             other.spillSerializationTimeNanos,
              other.spillWrites,
-             other.spillFlushTimeUs,
-             other.spillWriteTimeUs,
+             other.spillFlushTimeNanos,
+             other.spillWriteTimeNanos,
              spillMaxLevelExceededCount,
              spillReadBytes,
              spillReads,
-             spillReadTimeUs,
-             spillDeserializationTimeUs);
+             spillReadTimeNanos,
+             spillDeserializationTimeNanos);
 }
 
 void SpillStats::reset() {
@@ -213,44 +213,44 @@ void SpillStats::reset() {
   spilledRows = 0;
   spilledPartitions = 0;
   spilledFiles = 0;
-  spillFillTimeUs = 0;
-  spillSortTimeUs = 0;
-  spillSerializationTimeUs = 0;
+  spillFillTimeNanos = 0;
+  spillSortTimeNanos = 0;
+  spillSerializationTimeNanos = 0;
   spillWrites = 0;
-  spillFlushTimeUs = 0;
-  spillWriteTimeUs = 0;
+  spillFlushTimeNanos = 0;
+  spillWriteTimeNanos = 0;
   spillMaxLevelExceededCount = 0;
   spillReadBytes = 0;
   spillReads = 0;
-  spillReadTimeUs = 0;
-  spillDeserializationTimeUs = 0;
+  spillReadTimeNanos = 0;
+  spillDeserializationTimeNanos = 0;
 }
 
 std::string SpillStats::toString() const {
   return fmt::format(
       "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] spilledRows[{}] "
-      "spilledPartitions[{}] spilledFiles[{}] spillFillTimeUs[{}] "
-      "spillSortTime[{}] spillSerializationTime[{}] spillWrites[{}] "
-      "spillFlushTime[{}] spillWriteTime[{}] maxSpillExceededLimitCount[{}] "
-      "spillReadBytes[{}] spillReads[{}] spillReadTime[{}] "
-      "spillReadDeserializationTime[{}]",
+      "spilledPartitions[{}] spilledFiles[{}] spillFillTimeNanos[{}] "
+      "spillSortTimeNanos[{}] spillSerializationTimeNanos[{}] spillWrites[{}] "
+      "spillFlushTimeNanos[{}] spillWriteTimeNanos[{}] maxSpillExceededLimitCount[{}] "
+      "spillReadBytes[{}] spillReads[{}] spillReadTimeNanos[{}] "
+      "spillReadDeserializationTimeNanos[{}]",
       spillRuns,
       succinctBytes(spilledInputBytes),
       succinctBytes(spilledBytes),
       spilledRows,
       spilledPartitions,
       spilledFiles,
-      succinctMicros(spillFillTimeUs),
-      succinctMicros(spillSortTimeUs),
-      succinctMicros(spillSerializationTimeUs),
+      succinctNanos(spillFillTimeNanos),
+      succinctNanos(spillSortTimeNanos),
+      succinctNanos(spillSerializationTimeNanos),
       spillWrites,
-      succinctMicros(spillFlushTimeUs),
-      succinctMicros(spillWriteTimeUs),
+      succinctNanos(spillFlushTimeNanos),
+      succinctNanos(spillWriteTimeNanos),
       spillMaxLevelExceededCount,
       succinctBytes(spillReadBytes),
       spillReads,
-      succinctMicros(spillReadTimeUs),
-      succinctMicros(spillDeserializationTimeUs));
+      succinctNanos(spillReadTimeNanos),
+      succinctNanos(spillDeserializationTimeNanos));
 }
 
 void updateGlobalSpillRunStats(uint64_t numRuns) {
@@ -260,52 +260,54 @@ void updateGlobalSpillRunStats(uint64_t numRuns) {
 
 void updateGlobalSpillAppendStats(
     uint64_t numRows,
-    uint64_t serializationTimeUs) {
+    uint64_t serializationTimeNs) {
   RECORD_METRIC_VALUE(kMetricSpilledRowsCount, numRows);
   RECORD_HISTOGRAM_METRIC_VALUE(
-      kMetricSpillSerializationTimeMs, serializationTimeUs / 1'000);
+      kMetricSpillSerializationTimeMs, serializationTimeNs / 1'000'000);
   auto statsLocked = localSpillStats().wlock();
   statsLocked->spilledRows += numRows;
-  statsLocked->spillSerializationTimeUs += serializationTimeUs;
+  statsLocked->spillSerializationTimeNanos += serializationTimeNs;
 }
 
 void incrementGlobalSpilledPartitionStats() {
   ++localSpillStats().wlock()->spilledPartitions;
 }
 
-void updateGlobalSpillFillTime(uint64_t timeUs) {
-  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillFillTimeMs, timeUs / 1'000);
-  localSpillStats().wlock()->spillFillTimeUs += timeUs;
+void updateGlobalSpillFillTime(uint64_t timeNs) {
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillFillTimeMs, timeNs / 1'000'000);
+  localSpillStats().wlock()->spillFillTimeNanos += timeNs;
 }
 
-void updateGlobalSpillSortTime(uint64_t timeUs) {
-  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillSortTimeMs, timeUs / 1'000);
-  localSpillStats().wlock()->spillSortTimeUs += timeUs;
+void updateGlobalSpillSortTime(uint64_t timeNs) {
+  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillSortTimeMs, timeNs / 1'000'000);
+  localSpillStats().wlock()->spillSortTimeNanos += timeNs;
 }
 
 void updateGlobalSpillWriteStats(
     uint64_t spilledBytes,
-    uint64_t flushTimeUs,
-    uint64_t writeTimeUs) {
+    uint64_t flushTimeNs,
+    uint64_t writeTimeNs) {
   RECORD_METRIC_VALUE(kMetricSpillWritesCount);
   RECORD_METRIC_VALUE(kMetricSpilledBytes, spilledBytes);
-  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillFlushTimeMs, flushTimeUs / 1'000);
-  RECORD_HISTOGRAM_METRIC_VALUE(kMetricSpillWriteTimeMs, writeTimeUs / 1'000);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillFlushTimeMs, flushTimeNs / 1'000'000);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricSpillWriteTimeMs, writeTimeNs / 1'000'000);
   auto statsLocked = localSpillStats().wlock();
   ++statsLocked->spillWrites;
   statsLocked->spilledBytes += spilledBytes;
-  statsLocked->spillFlushTimeUs += flushTimeUs;
-  statsLocked->spillWriteTimeUs += writeTimeUs;
+  statsLocked->spillFlushTimeNanos += flushTimeNs;
+  statsLocked->spillWriteTimeNanos += writeTimeNs;
 }
 
 void updateGlobalSpillReadStats(
     uint64_t spillReads,
     uint64_t spillReadBytes,
-    uint64_t spillRadTimeUs) {
+    uint64_t spillReadTimeNs) {
   auto statsLocked = localSpillStats().wlock();
   statsLocked->spillReads += spillReads;
   statsLocked->spillReadBytes += spillReadBytes;
-  statsLocked->spillReadTimeUs += spillRadTimeUs;
+  statsLocked->spillReadTimeNanos += spillReadTimeNs;
 }
 
 void updateGlobalSpillMemoryBytes(uint64_t spilledInputBytes) {
@@ -325,8 +327,8 @@ void updateGlobalMaxSpillLevelExceededCount(
       maxSpillLevelExceededCount;
 }
 
-void updateGlobalSpillDeserializationTimeUs(uint64_t timeUs) {
-  localSpillStats().wlock()->spillDeserializationTimeUs += timeUs;
+void updateGlobalSpillDeserializationTimeNs(uint64_t timeNs) {
+  localSpillStats().wlock()->spillDeserializationTimeNanos += timeNs;
 }
 
 SpillStats globalSpillStats() {
diff --git a/velox/common/base/SpillStats.h b/velox/common/base/SpillStats.h
index 8b9ad7d11cac8..c6bbe735b513e 100644
--- a/velox/common/base/SpillStats.h
+++ b/velox/common/base/SpillStats.h
@@ -39,19 +39,19 @@ struct SpillStats {
   /// The number of spilled files.
   uint64_t spilledFiles{0};
   /// The time spent on filling rows for spilling.
-  uint64_t spillFillTimeUs{0};
+  uint64_t spillFillTimeNanos{0};
   /// The time spent on sorting rows for spilling.
-  uint64_t spillSortTimeUs{0};
+  uint64_t spillSortTimeNanos{0};
   /// The time spent on serializing rows for spilling.
-  uint64_t spillSerializationTimeUs{0};
+  uint64_t spillSerializationTimeNanos{0};
   /// The number of spill writer flushes, equivalent to number of write calls to
   /// underlying filesystem.
   uint64_t spillWrites{0};
   /// The time spent on copy out serialized rows for disk write. If compression
   /// is enabled, this includes the compression time.
-  uint64_t spillFlushTimeUs{0};
+  uint64_t spillFlushTimeNanos{0};
   /// The time spent on writing spilled rows to disk.
-  uint64_t spillWriteTimeUs{0};
+  uint64_t spillWriteTimeNanos{0};
   /// The number of times that an hash build operator exceeds the max spill
   /// limit.
   uint64_t spillMaxLevelExceededCount{0};
@@ -61,9 +61,9 @@ struct SpillStats {
   /// to the underlying filesystem.
   uint64_t spillReads{0};
   /// The time spent on read data from spilled files.
-  uint64_t spillReadTimeUs{0};
+  uint64_t spillReadTimeNanos{0};
   /// The time spent on deserializing rows read from spilled files.
-  uint64_t spillDeserializationTimeUs{0};
+  uint64_t spillDeserializationTimeNanos{0};
 
   SpillStats(
       uint64_t _spillRuns,
@@ -72,17 +72,17 @@ struct SpillStats {
       uint64_t _spilledRows,
       uint32_t _spilledPartitions,
       uint64_t _spilledFiles,
-      uint64_t _spillFillTimeUs,
-      uint64_t _spillSortTimeUs,
-      uint64_t _spillSerializationTimeUs,
+      uint64_t _spillFillTimeNanos,
+      uint64_t _spillSortTimeNanos,
+      uint64_t _spillSerializationTimeNanos,
       uint64_t _spillWrites,
-      uint64_t _spillFlushTimeUs,
-      uint64_t _spillWriteTimeUs,
+      uint64_t _spillFlushTimeNanos,
+      uint64_t _spillWriteTimeNanos,
       uint64_t _spillMaxLevelExceededCount,
       uint64_t _spillReadBytes,
       uint64_t _spillReads,
-      uint64_t _spillReadTimeUs,
-      uint64_t _spillDeserializationTimeUs);
+      uint64_t _spillReadTimeNanos,
+      uint64_t _spillDeserializationTimeNanos);
 
   SpillStats() = default;
 
@@ -157,7 +157,7 @@ void updateGlobalMaxSpillLevelExceededCount(
     uint64_t maxSpillLevelExceededCount);
 
 /// Increments the spill read deserialization time.
-void updateGlobalSpillDeserializationTimeUs(uint64_t timeUs);
+void updateGlobalSpillDeserializationTimeNs(uint64_t timeUs);
 
 /// Gets the cumulative global spill stats.
 SpillStats globalSpillStats();
diff --git a/velox/common/base/tests/SpillStatsTest.cpp b/velox/common/base/tests/SpillStatsTest.cpp
index 274774298877f..114c728fe4f02 100644
--- a/velox/common/base/tests/SpillStatsTest.cpp
+++ b/velox/common/base/tests/SpillStatsTest.cpp
@@ -29,18 +29,18 @@ TEST(SpillStatsTest, spillStats) {
   stats1.spilledBytes = 1024;
   stats1.spilledPartitions = 1024;
   stats1.spilledFiles = 1023;
-  stats1.spillWriteTimeUs = 1023;
-  stats1.spillFlushTimeUs = 1023;
+  stats1.spillWriteTimeNanos = 1023;
+  stats1.spillFlushTimeNanos = 1023;
   stats1.spillWrites = 1023;
-  stats1.spillSortTimeUs = 1023;
-  stats1.spillFillTimeUs = 1023;
+  stats1.spillSortTimeNanos = 1023;
+  stats1.spillFillTimeNanos = 1023;
   stats1.spilledRows = 1023;
-  stats1.spillSerializationTimeUs = 1023;
+  stats1.spillSerializationTimeNanos = 1023;
   stats1.spillMaxLevelExceededCount = 3;
   stats1.spillReadBytes = 1024;
   stats1.spillReads = 10;
-  stats1.spillReadTimeUs = 100;
-  stats1.spillDeserializationTimeUs = 100;
+  stats1.spillReadTimeNanos = 100;
+  stats1.spillDeserializationTimeNanos = 100;
   ASSERT_FALSE(stats1.empty());
   SpillStats stats2;
   stats2.spillRuns = 100;
@@ -48,18 +48,18 @@ TEST(SpillStatsTest, spillStats) {
   stats2.spilledBytes = 1024;
   stats2.spilledPartitions = 1025;
   stats2.spilledFiles = 1026;
-  stats2.spillWriteTimeUs = 1026;
-  stats2.spillFlushTimeUs = 1027;
+  stats2.spillWriteTimeNanos = 1026;
+  stats2.spillFlushTimeNanos = 1027;
   stats2.spillWrites = 1028;
-  stats2.spillSortTimeUs = 1029;
-  stats2.spillFillTimeUs = 1030;
+  stats2.spillSortTimeNanos = 1029;
+  stats2.spillFillTimeNanos = 1030;
   stats2.spilledRows = 1031;
-  stats2.spillSerializationTimeUs = 1032;
+  stats2.spillSerializationTimeNanos = 1032;
   stats2.spillMaxLevelExceededCount = 4;
   stats2.spillReadBytes = 2048;
   stats2.spillReads = 10;
-  stats2.spillReadTimeUs = 100;
-  stats2.spillDeserializationTimeUs = 100;
+  stats2.spillReadTimeNanos = 100;
+  stats2.spillDeserializationTimeNanos = 100;
   ASSERT_TRUE(stats1 < stats2);
   ASSERT_TRUE(stats1 <= stats2);
   ASSERT_FALSE(stats1 > stats2);
@@ -79,34 +79,34 @@ TEST(SpillStatsTest, spillStats) {
   ASSERT_EQ(delta.spilledBytes, 0);
   ASSERT_EQ(delta.spilledPartitions, 1);
   ASSERT_EQ(delta.spilledFiles, 3);
-  ASSERT_EQ(delta.spillWriteTimeUs, 3);
-  ASSERT_EQ(delta.spillFlushTimeUs, 4);
+  ASSERT_EQ(delta.spillWriteTimeNanos, 3);
+  ASSERT_EQ(delta.spillFlushTimeNanos, 4);
   ASSERT_EQ(delta.spillWrites, 5);
-  ASSERT_EQ(delta.spillSortTimeUs, 6);
-  ASSERT_EQ(delta.spillFillTimeUs, 7);
+  ASSERT_EQ(delta.spillSortTimeNanos, 6);
+  ASSERT_EQ(delta.spillFillTimeNanos, 7);
   ASSERT_EQ(delta.spilledRows, 8);
-  ASSERT_EQ(delta.spillSerializationTimeUs, 9);
+  ASSERT_EQ(delta.spillSerializationTimeNanos, 9);
   ASSERT_EQ(delta.spillReadBytes, 1024);
   ASSERT_EQ(delta.spillReads, 0);
-  ASSERT_EQ(delta.spillReadTimeUs, 0);
-  ASSERT_EQ(delta.spillDeserializationTimeUs, 0);
+  ASSERT_EQ(delta.spillReadTimeNanos, 0);
+  ASSERT_EQ(delta.spillDeserializationTimeNanos, 0);
   delta = stats1 - stats2;
   ASSERT_EQ(delta.spilledInputBytes, 0);
   ASSERT_EQ(delta.spilledBytes, 0);
   ASSERT_EQ(delta.spilledPartitions, -1);
   ASSERT_EQ(delta.spilledFiles, -3);
-  ASSERT_EQ(delta.spillWriteTimeUs, -3);
-  ASSERT_EQ(delta.spillFlushTimeUs, -4);
+  ASSERT_EQ(delta.spillWriteTimeNanos, -3);
+  ASSERT_EQ(delta.spillFlushTimeNanos, -4);
   ASSERT_EQ(delta.spillWrites, -5);
-  ASSERT_EQ(delta.spillSortTimeUs, -6);
-  ASSERT_EQ(delta.spillFillTimeUs, -7);
+  ASSERT_EQ(delta.spillSortTimeNanos, -6);
+  ASSERT_EQ(delta.spillFillTimeNanos, -7);
   ASSERT_EQ(delta.spilledRows, -8);
-  ASSERT_EQ(delta.spillSerializationTimeUs, -9);
+  ASSERT_EQ(delta.spillSerializationTimeNanos, -9);
   ASSERT_EQ(delta.spillMaxLevelExceededCount, -1);
   ASSERT_EQ(delta.spillReadBytes, -1024);
   ASSERT_EQ(delta.spillReads, 0);
-  ASSERT_EQ(delta.spillReadTimeUs, 0);
-  ASSERT_EQ(delta.spillDeserializationTimeUs, 0);
+  ASSERT_EQ(delta.spillReadTimeNanos, 0);
+  ASSERT_EQ(delta.spillDeserializationTimeNanos, 0);
   stats1.spilledInputBytes = 2060;
   stats1.spilledBytes = 1030;
   stats1.spillReadBytes = 4096;
@@ -123,19 +123,19 @@ TEST(SpillStatsTest, spillStats) {
       stats2.toString(),
       "spillRuns[100] spilledInputBytes[2.00KB] spilledBytes[1.00KB] "
       "spilledRows[1031] spilledPartitions[1025] spilledFiles[1026] "
-      "spillFillTimeUs[1.03ms] spillSortTime[1.03ms] "
-      "spillSerializationTime[1.03ms] spillWrites[1028] spillFlushTime[1.03ms] "
-      "spillWriteTime[1.03ms] maxSpillExceededLimitCount[4] "
-      "spillReadBytes[2.00KB] spillReads[10] spillReadTime[100us] "
-      "spillReadDeserializationTime[100us]");
+      "spillFillTimeNanos[1.03us] spillSortTimeNanos[1.03us] "
+      "spillSerializationTimeNanos[1.03us] spillWrites[1028] spillFlushTimeNanos[1.03us] "
+      "spillWriteTimeNanos[1.03us] maxSpillExceededLimitCount[4] "
+      "spillReadBytes[2.00KB] spillReads[10] spillReadTimeNanos[100ns] "
+      "spillReadDeserializationTimeNanos[100ns]");
   ASSERT_EQ(
       fmt::format("{}", stats2),
       "spillRuns[100] spilledInputBytes[2.00KB] spilledBytes[1.00KB] "
       "spilledRows[1031] spilledPartitions[1025] spilledFiles[1026] "
-      "spillFillTimeUs[1.03ms] spillSortTime[1.03ms] "
-      "spillSerializationTime[1.03ms] spillWrites[1028] "
-      "spillFlushTime[1.03ms] spillWriteTime[1.03ms] "
+      "spillFillTimeNanos[1.03us] spillSortTimeNanos[1.03us] "
+      "spillSerializationTimeNanos[1.03us] spillWrites[1028] "
+      "spillFlushTimeNanos[1.03us] spillWriteTimeNanos[1.03us] "
       "maxSpillExceededLimitCount[4] "
-      "spillReadBytes[2.00KB] spillReads[10] spillReadTime[100us] "
-      "spillReadDeserializationTime[100us]");
+      "spillReadBytes[2.00KB] spillReads[10] spillReadTimeNanos[100ns] "
+      "spillReadDeserializationTimeNanos[100ns]");
 }
diff --git a/velox/common/time/Timer.h b/velox/common/time/Timer.h
index e668d188b1a1a..ce3d8ceb03860 100644
--- a/velox/common/time/Timer.h
+++ b/velox/common/time/Timer.h
@@ -44,6 +44,24 @@ class MicrosecondTimer {
   uint64_t* timer_;
 };
 
+class NanosecondTimer {
+ public:
+  explicit NanosecondTimer(uint64_t* timer) : timer_(timer) {
+    start_ = std::chrono::steady_clock::now();
+  }
+
+  ~NanosecondTimer() {
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+        std::chrono::steady_clock::now() - start_);
+
+    (*timer_) += duration.count();
+  }
+
+ private:
+  std::chrono::steady_clock::time_point start_;
+  uint64_t* timer_;
+};
+
 /// Measures the time between construction and destruction with CPU clock
 /// counter (rdtsc on X86) and increments a user-supplied counter with the cycle
 /// count.
diff --git a/velox/connectors/hive/tests/HiveDataSinkTest.cpp b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
index c8d959b2f5c9c..96f85b02b9402 100644
--- a/velox/connectors/hive/tests/HiveDataSinkTest.cpp
+++ b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
@@ -492,10 +492,10 @@ TEST_F(HiveDataSinkTest, basic) {
       stats.toString(),
       "numWrittenBytes 0B numWrittenFiles 0 spillRuns[0] spilledInputBytes[0B] "
       "spilledBytes[0B] spilledRows[0] spilledPartitions[0] spilledFiles[0] "
-      "spillFillTimeUs[0us] spillSortTime[0us] spillSerializationTime[0us] "
-      "spillWrites[0] spillFlushTime[0us] spillWriteTime[0us] "
+      "spillFillTimeNanos[0ns] spillSortTimeNanos[0ns] spillSerializationTimeNanos[0ns] "
+      "spillWrites[0] spillFlushTimeNanos[0ns] spillWriteTimeNanos[0ns] "
       "maxSpillExceededLimitCount[0] spillReadBytes[0B] spillReads[0] "
-      "spillReadTime[0us] spillReadDeserializationTime[0us]");
+      "spillReadTimeNanos[0ns] spillReadDeserializationTimeNanos[0ns]");
 
   const int numBatches = 10;
   const auto vectors = createVectors(500, numBatches);
@@ -540,10 +540,10 @@ TEST_F(HiveDataSinkTest, basicBucket) {
       stats.toString(),
       "numWrittenBytes 0B numWrittenFiles 0 spillRuns[0] spilledInputBytes[0B] "
       "spilledBytes[0B] spilledRows[0] spilledPartitions[0] spilledFiles[0] "
-      "spillFillTimeUs[0us] spillSortTime[0us] spillSerializationTime[0us] "
-      "spillWrites[0] spillFlushTime[0us] spillWriteTime[0us] "
+      "spillFillTimeNanos[0ns] spillSortTimeNanos[0ns] spillSerializationTimeNanos[0ns] "
+      "spillWrites[0] spillFlushTimeNanos[0ns] spillWriteTimeNanos[0ns] "
       "maxSpillExceededLimitCount[0] spillReadBytes[0B] spillReads[0] "
-      "spillReadTime[0us] spillReadDeserializationTime[0us]");
+      "spillReadTimeNanos[0ns] spillReadDeserializationTimeNanos[0ns]");
 
   const int numBatches = 10;
   const auto vectors = createVectors(500, numBatches);
diff --git a/velox/exec/HashProbe.cpp b/velox/exec/HashProbe.cpp
index f9df0370635d5..95f060b789148 100644
--- a/velox/exec/HashProbe.cpp
+++ b/velox/exec/HashProbe.cpp
@@ -1512,7 +1512,7 @@ void HashProbe::noMoreInputInternal() {
         spillInputPartitionIds_.size(),
         inputSpiller_->spilledPartitionSet().size());
     inputSpiller_->finishSpill(spillPartitionSet_);
-    VELOX_CHECK_EQ(spillStats_.rlock()->spillSortTimeUs, 0);
+    VELOX_CHECK_EQ(spillStats_.rlock()->spillSortTimeNanos, 0);
   }
 
   const bool hasSpillEnabled = spillEnabled();
diff --git a/velox/exec/Operator.cpp b/velox/exec/Operator.cpp
index 9f46464cf2b54..0eacee7ca4a89 100644
--- a/velox/exec/Operator.cpp
+++ b/velox/exec/Operator.cpp
@@ -300,55 +300,40 @@ void Operator::recordSpillStats() {
   lockedStats->spilledRows += lockedSpillStats->spilledRows;
   lockedStats->spilledPartitions += lockedSpillStats->spilledPartitions;
   lockedStats->spilledFiles += lockedSpillStats->spilledFiles;
-  if (lockedSpillStats->spillFillTimeUs != 0) {
+  if (lockedSpillStats->spillFillTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillFillTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                lockedSpillStats->spillFillTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
-            RuntimeCounter::Unit::kNanos});
+            static_cast<int64_t>(lockedSpillStats->spillFillTimeNanos)});
   }
-  if (lockedSpillStats->spillSortTimeUs != 0) {
+  if (lockedSpillStats->spillSortTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillSortTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                lockedSpillStats->spillSortTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
-            RuntimeCounter::Unit::kNanos});
+            static_cast<int64_t>(lockedSpillStats->spillSortTimeNanos)});
   }
-  if (lockedSpillStats->spillSerializationTimeUs != 0) {
+  if (lockedSpillStats->spillSerializationTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillSerializationTime,
-        RuntimeCounter{
-            static_cast<int64_t>(
-                lockedSpillStats->spillSerializationTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
-            RuntimeCounter::Unit::kNanos});
+        RuntimeCounter{static_cast<int64_t>(
+            lockedSpillStats->spillSerializationTimeNanos)});
   }
-  if (lockedSpillStats->spillFlushTimeUs != 0) {
+  if (lockedSpillStats->spillFlushTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillFlushTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                lockedSpillStats->spillFlushTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
-            RuntimeCounter::Unit::kNanos});
+            static_cast<int64_t>(lockedSpillStats->spillFlushTimeNanos)});
   }
   if (lockedSpillStats->spillWrites != 0) {
     lockedStats->addRuntimeStat(
         kSpillWrites,
         RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillWrites)});
   }
-  if (lockedSpillStats->spillWriteTimeUs != 0) {
+  if (lockedSpillStats->spillWriteTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillWriteTime,
         RuntimeCounter{
-            static_cast<int64_t>(
-                lockedSpillStats->spillWriteTimeUs *
-                Timestamp::kNanosecondsInMicrosecond),
-            RuntimeCounter::Unit::kNanos});
+            static_cast<int64_t>(lockedSpillStats->spillWriteTimeNanos)});
   }
   if (lockedSpillStats->spillRuns != 0) {
     lockedStats->addRuntimeStat(
@@ -380,22 +365,18 @@ void Operator::recordSpillStats() {
         RuntimeCounter{static_cast<int64_t>(lockedSpillStats->spillReads)});
   }
 
-  if (lockedSpillStats->spillReadTimeUs != 0) {
+  if (lockedSpillStats->spillReadTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillReadTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillReadTimeUs) *
-                Timestamp::kNanosecondsInMicrosecond,
-            RuntimeCounter::Unit::kNanos});
+            static_cast<int64_t>(lockedSpillStats->spillReadTimeNanos)});
   }
 
-  if (lockedSpillStats->spillDeserializationTimeUs != 0) {
+  if (lockedSpillStats->spillDeserializationTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillDeserializationTime,
-        RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillDeserializationTimeUs) *
-                Timestamp::kNanosecondsInMicrosecond,
-            RuntimeCounter::Unit::kNanos});
+        RuntimeCounter{static_cast<int64_t>(
+            lockedSpillStats->spillDeserializationTimeNanos)});
   }
   lockedSpillStats->reset();
 }
diff --git a/velox/exec/SpillFile.cpp b/velox/exec/SpillFile.cpp
index 912a11f0c4826..8aaf6a2f86d51 100644
--- a/velox/exec/SpillFile.cpp
+++ b/velox/exec/SpillFile.cpp
@@ -144,21 +144,21 @@ uint64_t SpillWriter::flush() {
 
   IOBufOutputStream out(
       *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
-  uint64_t flushTimeUs{0};
+  uint64_t flushTimeNs{0};
   {
-    MicrosecondTimer timer(&flushTimeUs);
+    NanosecondTimer timer(&flushTimeNs);
     batch_->flush(&out);
   }
   batch_.reset();
 
-  uint64_t writeTimeUs{0};
+  uint64_t writeTimeNs{0};
   uint64_t writtenBytes{0};
   auto iobuf = out.getIOBuf();
   {
-    MicrosecondTimer timer(&writeTimeUs);
+    NanosecondTimer timer(&writeTimeNs);
     writtenBytes = file->write(std::move(iobuf));
   }
-  updateWriteStats(writtenBytes, flushTimeUs, writeTimeUs);
+  updateWriteStats(writtenBytes, flushTimeNs, writeTimeNs);
   updateAndCheckSpillLimitCb_(writtenBytes);
   return writtenBytes;
 }
@@ -168,9 +168,9 @@ uint64_t SpillWriter::write(
     const folly::Range<IndexRange*>& indices) {
   checkNotFinished();
 
-  uint64_t timeUs{0};
+  uint64_t timeNs{0};
   {
-    MicrosecondTimer timer(&timeUs);
+    NanosecondTimer timer(&timeNs);
     if (batch_ == nullptr) {
       serializer::presto::PrestoVectorSerde::PrestoOptions options = {
           kDefaultUseLosslessTimestamp, compressionKind_, true /*nullsFirst*/};
@@ -182,7 +182,7 @@ uint64_t SpillWriter::write(
     }
     batch_->append(rows, indices);
   }
-  updateAppendStats(rows->size(), timeUs);
+  updateAppendStats(rows->size(), timeNs);
   if (batch_->size() < writeBufferSize_) {
     return 0;
   }
@@ -191,24 +191,24 @@ uint64_t SpillWriter::write(
 
 void SpillWriter::updateAppendStats(
     uint64_t numRows,
-    uint64_t serializationTimeUs) {
+    uint64_t serializationTimeNs) {
   auto statsLocked = stats_->wlock();
   statsLocked->spilledRows += numRows;
-  statsLocked->spillSerializationTimeUs += serializationTimeUs;
-  common::updateGlobalSpillAppendStats(numRows, serializationTimeUs);
+  statsLocked->spillSerializationTimeNanos += serializationTimeNs;
+  common::updateGlobalSpillAppendStats(numRows, serializationTimeNs);
 }
 
 void SpillWriter::updateWriteStats(
     uint64_t spilledBytes,
-    uint64_t flushTimeUs,
-    uint64_t fileWriteTimeUs) {
+    uint64_t flushTimeNs,
+    uint64_t fileWriteTimeNs) {
   auto statsLocked = stats_->wlock();
   statsLocked->spilledBytes += spilledBytes;
-  statsLocked->spillFlushTimeUs += flushTimeUs;
-  statsLocked->spillWriteTimeUs += fileWriteTimeUs;
+  statsLocked->spillFlushTimeNanos += flushTimeNs;
+  statsLocked->spillWriteTimeNanos += fileWriteTimeNs;
   ++statsLocked->spillWrites;
   common::updateGlobalSpillWriteStats(
-      spilledBytes, flushTimeUs, fileWriteTimeUs);
+      spilledBytes, flushTimeNs, fileWriteTimeNs);
 }
 
 void SpillWriter::updateSpilledFileStats(uint64_t fileSize) {
@@ -313,14 +313,14 @@ bool SpillReadFile::nextBatch(RowVectorPtr& rowVector) {
     return false;
   }
 
-  uint64_t timeUs{0};
+  uint64_t timeNs{0};
   {
-    MicrosecondTimer timer{&timeUs};
+    NanosecondTimer timer{&timeNs};
     VectorStreamGroup::read(
         input_.get(), pool_, type_, &rowVector, &readOptions_);
   }
-  stats_->wlock()->spillDeserializationTimeUs += timeUs;
-  common::updateGlobalSpillDeserializationTimeUs(timeUs);
+  stats_->wlock()->spillDeserializationTimeNanos += timeNs;
+  common::updateGlobalSpillDeserializationTimeNs(timeNs);
   return true;
 }
 
@@ -328,10 +328,13 @@ void SpillReadFile::recordSpillStats() {
   VELOX_CHECK(input_->atEnd());
   const auto readStats = input_->stats();
   common::updateGlobalSpillReadStats(
-      readStats.numReads, readStats.readBytes, readStats.readTimeUs);
+      readStats.numReads,
+      readStats.readBytes,
+      readStats.readTimeUs * Timestamp::kNanosecondsInMicrosecond);
   auto lockedSpillStats = stats_->wlock();
   lockedSpillStats->spillReads += readStats.numReads;
-  lockedSpillStats->spillReadTimeUs += readStats.readTimeUs;
+  lockedSpillStats->spillReadTimeNanos +=
+      readStats.readTimeUs * Timestamp::kNanosecondsInMicrosecond;
   lockedSpillStats->spillReadBytes += readStats.readBytes;
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Spiller.cpp b/velox/exec/Spiller.cpp
index 67a2196c67fad..96c38f67e2ed3 100644
--- a/velox/exec/Spiller.cpp
+++ b/velox/exec/Spiller.cpp
@@ -413,9 +413,9 @@ void Spiller::ensureSorted(SpillRun& run) {
     return;
   }
 
-  uint64_t sortTimeUs{0};
+  uint64_t sortTimeNs{0};
   {
-    MicrosecondTimer timer(&sortTimeUs);
+    NanosecondTimer timer(&sortTimeNs);
     gfx::timsort(
         run.rows.begin(),
         run.rows.end(),
@@ -428,7 +428,7 @@ void Spiller::ensureSorted(SpillRun& run) {
 
   // NOTE: Always set a non-zero sort time to avoid flakiness in tests which
   // check sort time.
-  updateSpillSortTime(std::max<uint64_t>(1, sortTimeUs));
+  updateSpillSortTime(std::max<uint64_t>(1, sortTimeNs));
 }
 
 std::unique_ptr<Spiller::SpillStatus> Spiller::writeSpill(int32_t partition) {
@@ -525,14 +525,14 @@ void Spiller::runSpill(bool lastRun) {
   }
 }
 
-void Spiller::updateSpillFillTime(uint64_t timeUs) {
-  spillStats_->wlock()->spillFillTimeUs += timeUs;
-  common::updateGlobalSpillFillTime(timeUs);
+void Spiller::updateSpillFillTime(uint64_t timeNs) {
+  spillStats_->wlock()->spillFillTimeNanos += timeNs;
+  common::updateGlobalSpillFillTime(timeNs);
 }
 
-void Spiller::updateSpillSortTime(uint64_t timeUs) {
-  spillStats_->wlock()->spillSortTimeUs += timeUs;
-  common::updateGlobalSpillSortTime(timeUs);
+void Spiller::updateSpillSortTime(uint64_t timeNs) {
+  spillStats_->wlock()->spillSortTimeNanos += timeNs;
+  common::updateGlobalSpillSortTime(timeNs);
 }
 
 bool Spiller::needSort() const {
@@ -644,9 +644,9 @@ bool Spiller::fillSpillRuns(RowContainerIterator* iterator) {
   checkEmptySpillRuns();
 
   bool lastRun{false};
-  uint64_t execTimeUs{0};
+  uint64_t execTimeNs{0};
   {
-    MicrosecondTimer timer(&execTimeUs);
+    NanosecondTimer timer(&execTimeNs);
 
     // Number of rows to hash and divide into spill partitions at a time.
     constexpr int32_t kHashBatchSize = 4096;
@@ -690,7 +690,7 @@ bool Spiller::fillSpillRuns(RowContainerIterator* iterator) {
       }
     }
   }
-  updateSpillFillTime(execTimeUs);
+  updateSpillFillTime(execTimeNs);
 
   return lastRun;
 }
@@ -698,16 +698,16 @@ bool Spiller::fillSpillRuns(RowContainerIterator* iterator) {
 void Spiller::fillSpillRun(std::vector<char*>& rows) {
   VELOX_CHECK_EQ(bits_.numPartitions(), 1);
   checkEmptySpillRuns();
-  uint64_t execTimeUs{0};
+  uint64_t execTimeNs{0};
   {
-    MicrosecondTimer timer(&execTimeUs);
+    NanosecondTimer timer(&execTimeNs);
     spillRuns_[0].rows =
         SpillRows(rows.begin(), rows.end(), spillRuns_[0].rows.get_allocator());
     for (const auto* row : rows) {
       spillRuns_[0].numBytes += container_->rowSize(row);
     }
   }
-  updateSpillFillTime(execTimeUs);
+  updateSpillFillTime(execTimeNs);
 }
 
 std::string Spiller::toString() const {
diff --git a/velox/exec/tests/SpillTest.cpp b/velox/exec/tests/SpillTest.cpp
index e7cbe7a006137..e611bdb103cb4 100644
--- a/velox/exec/tests/SpillTest.cpp
+++ b/velox/exec/tests/SpillTest.cpp
@@ -293,12 +293,12 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     ASSERT_GT(stats.spillWrites, 0);
     // NOTE: On fast machines we might have sub-microsecond in each write,
     // resulting in 0us total write time.
-    ASSERT_GE(stats.spillWriteTimeUs, 0);
-    ASSERT_GE(stats.spillFlushTimeUs, 0);
+    ASSERT_GE(stats.spillWriteTimeNanos, 0);
+    ASSERT_GE(stats.spillFlushTimeNanos, 0);
     ASSERT_GT(stats.spilledRows, 0);
     // NOTE: the following stats are not collected by spill state.
-    ASSERT_EQ(stats.spillFillTimeUs, 0);
-    ASSERT_EQ(stats.spillSortTimeUs, 0);
+    ASSERT_EQ(stats.spillFillTimeNanos, 0);
+    ASSERT_EQ(stats.spillSortTimeNanos, 0);
     const auto newGStats = common::globalSpillStats();
     ASSERT_EQ(
         prevGStats.spilledPartitions + stats.spilledPartitions,
@@ -310,19 +310,19 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     ASSERT_EQ(
         prevGStats.spillWrites + stats.spillWrites, newGStats.spillWrites);
     ASSERT_EQ(
-        prevGStats.spillWriteTimeUs + stats.spillWriteTimeUs,
-        newGStats.spillWriteTimeUs);
+        prevGStats.spillWriteTimeNanos + stats.spillWriteTimeNanos,
+        newGStats.spillWriteTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillFlushTimeUs + stats.spillFlushTimeUs,
-        newGStats.spillFlushTimeUs);
+        prevGStats.spillFlushTimeNanos + stats.spillFlushTimeNanos,
+        newGStats.spillFlushTimeNanos);
     ASSERT_EQ(
         prevGStats.spilledRows + stats.spilledRows, newGStats.spilledRows);
     ASSERT_EQ(
-        prevGStats.spillFillTimeUs + stats.spillFillTimeUs,
-        newGStats.spillFillTimeUs);
+        prevGStats.spillFillTimeNanos + stats.spillFillTimeNanos,
+        newGStats.spillFillTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillSortTimeUs + stats.spillSortTimeUs,
-        newGStats.spillSortTimeUs);
+        prevGStats.spillSortTimeNanos + stats.spillSortTimeNanos,
+        newGStats.spillSortTimeNanos);
 
     // Verifies the spill file id
     for (auto& partitionNum : state_->spilledPartitionSet()) {
@@ -395,35 +395,33 @@ class SpillTest : public ::testing::TestWithParam<common::CompressionKind>,
     const auto finalStats = spillStats_.copy();
     ASSERT_EQ(finalStats.spillReadBytes, finalStats.spilledBytes);
     ASSERT_GT(finalStats.spillReads, 0);
-    ASSERT_GT(finalStats.spillReadTimeUs, 0);
-    ASSERT_GT(finalStats.spillDeserializationTimeUs, 0);
-
+    ASSERT_GT(finalStats.spillReadTimeNanos, 0);
+    ASSERT_GT(finalStats.spillDeserializationTimeNanos, 0);
     ASSERT_EQ(
         finalStats.toString(),
         fmt::format(
-            "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] "
-            "spilledRows[{}] spilledPartitions[{}] spilledFiles[{}] "
-            "spillFillTimeUs[{}] spillSortTime[{}] spillSerializationTime[{}] "
-            "spillWrites[{}] spillFlushTime[{}] spillWriteTime[{}] "
-            "maxSpillExceededLimitCount[0] spillReadBytes[{}] spillReads[{}] "
-            "spillReadTime[{}] spillReadDeserializationTime[{}]",
+            "spillRuns[{}] spilledInputBytes[{}] spilledBytes[{}] spilledRows[{}] "
+            "spilledPartitions[{}] spilledFiles[{}] spillFillTimeNanos[{}] "
+            "spillSortTimeNanos[{}] spillSerializationTimeNanos[{}] spillWrites[{}] "
+            "spillFlushTimeNanos[{}] spillWriteTimeNanos[{}] maxSpillExceededLimitCount[0] "
+            "spillReadBytes[{}] spillReads[{}] spillReadTimeNanos[{}] "
+            "spillReadDeserializationTimeNanos[{}]",
             finalStats.spillRuns,
             succinctBytes(finalStats.spilledInputBytes),
             succinctBytes(finalStats.spilledBytes),
             finalStats.spilledRows,
             finalStats.spilledPartitions,
             finalStats.spilledFiles,
-            succinctMicros(finalStats.spillFillTimeUs),
-            succinctMicros(finalStats.spillSortTimeUs),
-            succinctMicros(finalStats.spillSerializationTimeUs),
+            succinctNanos(finalStats.spillFillTimeNanos),
+            succinctNanos(finalStats.spillSortTimeNanos),
+            succinctNanos(finalStats.spillSerializationTimeNanos),
             finalStats.spillWrites,
-            succinctMicros(finalStats.spillFlushTimeUs),
-            succinctMicros(finalStats.spillWriteTimeUs),
+            succinctNanos(finalStats.spillFlushTimeNanos),
+            succinctNanos(finalStats.spillWriteTimeNanos),
             succinctBytes(finalStats.spillReadBytes),
             finalStats.spillReads,
-            succinctMicros(finalStats.spillReadTimeUs),
-            succinctMicros(finalStats.spillDeserializationTimeUs)));
-
+            succinctNanos(finalStats.spillReadTimeNanos),
+            succinctNanos(finalStats.spillDeserializationTimeNanos)));
     // Verify the spilled files are still there after spill state destruction.
     for (const auto& spilledFile : spilledFileSet) {
       ASSERT_TRUE(fs->exists(spilledFile));
diff --git a/velox/exec/tests/SpillerTest.cpp b/velox/exec/tests/SpillerTest.cpp
index a88c62f9a493f..4d1db05164b18 100644
--- a/velox/exec/tests/SpillerTest.cpp
+++ b/velox/exec/tests/SpillerTest.cpp
@@ -290,15 +290,15 @@ class SpillerTest : public exec::test::RowContainerTestBase {
 
     ASSERT_EQ(stats.spilledBytes, totalSpilledBytes);
     ASSERT_EQ(stats.spillReadBytes, totalSpilledBytes);
-    ASSERT_GT(stats.spillWriteTimeUs, 0);
+    ASSERT_GT(stats.spillWriteTimeNanos, 0);
     if (type_ == Spiller::Type::kAggregateOutput) {
-      ASSERT_EQ(stats.spillSortTimeUs, 0);
+      ASSERT_EQ(stats.spillSortTimeNanos, 0);
     } else {
-      ASSERT_GT(stats.spillSortTimeUs, 0);
+      ASSERT_GT(stats.spillSortTimeNanos, 0);
     }
-    ASSERT_GT(stats.spillFlushTimeUs, 0);
-    ASSERT_GT(stats.spillFillTimeUs, 0);
-    ASSERT_GT(stats.spillSerializationTimeUs, 0);
+    ASSERT_GT(stats.spillFlushTimeNanos, 0);
+    ASSERT_GT(stats.spillFillTimeNanos, 0);
+    ASSERT_GT(stats.spillSerializationTimeNanos, 0);
     ASSERT_GT(stats.spillWrites, 0);
 
     const auto newGStats = common::globalSpillStats();
@@ -316,29 +316,30 @@ class SpillerTest : public exec::test::RowContainerTestBase {
         newGStats.spillReadBytes);
     ASSERT_EQ(prevGStats.spillReads + stats.spillReads, newGStats.spillReads);
     ASSERT_EQ(
-        prevGStats.spillReadTimeUs + stats.spillReadTimeUs,
-        newGStats.spillReadTimeUs);
+        prevGStats.spillReadTimeNanos + stats.spillReadTimeNanos,
+        newGStats.spillReadTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillDeserializationTimeUs +
-            stats.spillDeserializationTimeUs,
-        newGStats.spillDeserializationTimeUs);
+        prevGStats.spillDeserializationTimeNanos +
+            stats.spillDeserializationTimeNanos,
+        newGStats.spillDeserializationTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillWriteTimeUs + stats.spillWriteTimeUs,
-        newGStats.spillWriteTimeUs);
+        prevGStats.spillWriteTimeNanos + stats.spillWriteTimeNanos,
+        newGStats.spillWriteTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillSortTimeUs + stats.spillSortTimeUs,
-        newGStats.spillSortTimeUs);
+        prevGStats.spillSortTimeNanos + stats.spillSortTimeNanos,
+        newGStats.spillSortTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillFlushTimeUs + stats.spillFlushTimeUs,
-        newGStats.spillFlushTimeUs)
-        << prevGStats.spillFlushTimeUs << " " << stats.spillFlushTimeUs << " "
-        << newGStats.spillFlushTimeUs;
+        prevGStats.spillFlushTimeNanos + stats.spillFlushTimeNanos,
+        newGStats.spillFlushTimeNanos)
+        << prevGStats.spillFlushTimeNanos << " " << stats.spillFlushTimeNanos
+        << " " << newGStats.spillFlushTimeNanos;
     ASSERT_EQ(
-        prevGStats.spillFillTimeUs + stats.spillFillTimeUs,
-        newGStats.spillFillTimeUs);
+        prevGStats.spillFillTimeNanos + stats.spillFillTimeNanos,
+        newGStats.spillFillTimeNanos);
     ASSERT_EQ(
-        prevGStats.spillSerializationTimeUs + stats.spillSerializationTimeUs,
-        newGStats.spillSerializationTimeUs);
+        prevGStats.spillSerializationTimeNanos +
+            stats.spillSerializationTimeNanos,
+        newGStats.spillSerializationTimeNanos);
     ASSERT_EQ(
         prevGStats.spillWrites + stats.spillWrites, newGStats.spillWrites);
 
@@ -846,33 +847,33 @@ class SpillerTest : public exec::test::RowContainerTestBase {
         if (numAppendBatches == 0) {
           ASSERT_EQ(stats.spilledRows, 0);
           ASSERT_EQ(stats.spilledBytes, 0);
-          ASSERT_EQ(stats.spillWriteTimeUs, 0);
-          ASSERT_EQ(stats.spillFlushTimeUs, 0);
-          ASSERT_EQ(stats.spillSerializationTimeUs, 0);
+          ASSERT_EQ(stats.spillWriteTimeNanos, 0);
+          ASSERT_EQ(stats.spillFlushTimeNanos, 0);
+          ASSERT_EQ(stats.spillSerializationTimeNanos, 0);
           ASSERT_EQ(stats.spillWrites, 0);
         } else {
           ASSERT_GT(stats.spilledRows, 0);
           ASSERT_GT(stats.spilledBytes, 0);
-          ASSERT_GT(stats.spillWriteTimeUs, 0);
-          ASSERT_GT(stats.spillFlushTimeUs, 0);
-          ASSERT_GT(stats.spillSerializationTimeUs, 0);
+          ASSERT_GT(stats.spillWriteTimeNanos, 0);
+          ASSERT_GT(stats.spillFlushTimeNanos, 0);
+          ASSERT_GT(stats.spillSerializationTimeNanos, 0);
           ASSERT_GT(stats.spillWrites, 0);
         }
       } else {
         ASSERT_GT(stats.spilledRows, 0);
         ASSERT_GT(stats.spilledBytes, 0);
-        ASSERT_GT(stats.spillWriteTimeUs, 0);
-        ASSERT_GT(stats.spillFlushTimeUs, 0);
-        ASSERT_GT(stats.spillSerializationTimeUs, 0);
+        ASSERT_GT(stats.spillWriteTimeNanos, 0);
+        ASSERT_GT(stats.spillFlushTimeNanos, 0);
+        ASSERT_GT(stats.spillSerializationTimeNanos, 0);
         ASSERT_GT(stats.spillWrites, 0);
       }
       ASSERT_GT(stats.spilledPartitions, 0);
-      ASSERT_EQ(stats.spillSortTimeUs, 0);
+      ASSERT_EQ(stats.spillSortTimeNanos, 0);
       if (type_ == Spiller::Type::kHashJoinBuild ||
           type_ == Spiller::Type::kRowNumber) {
-        ASSERT_GT(stats.spillFillTimeUs, 0);
+        ASSERT_GT(stats.spillFillTimeNanos, 0);
       } else {
-        ASSERT_EQ(stats.spillFillTimeUs, 0);
+        ASSERT_EQ(stats.spillFillTimeNanos, 0);
       }
 
       const auto newGStats = common::globalSpillStats();
@@ -886,22 +887,23 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       ASSERT_EQ(
           prevGStats.spilledBytes + stats.spilledBytes, newGStats.spilledBytes);
       ASSERT_EQ(
-          prevGStats.spillWriteTimeUs + stats.spillWriteTimeUs,
-          newGStats.spillWriteTimeUs);
+          prevGStats.spillWriteTimeNanos + stats.spillWriteTimeNanos,
+          newGStats.spillWriteTimeNanos);
       ASSERT_EQ(
-          prevGStats.spillSortTimeUs + stats.spillSortTimeUs,
-          newGStats.spillSortTimeUs);
+          prevGStats.spillSortTimeNanos + stats.spillSortTimeNanos,
+          newGStats.spillSortTimeNanos);
       ASSERT_EQ(
-          prevGStats.spillFlushTimeUs + stats.spillFlushTimeUs,
-          newGStats.spillFlushTimeUs)
-          << prevGStats.spillFlushTimeUs << " " << stats.spillFlushTimeUs << " "
-          << newGStats.spillFlushTimeUs;
+          prevGStats.spillFlushTimeNanos + stats.spillFlushTimeNanos,
+          newGStats.spillFlushTimeNanos)
+          << prevGStats.spillFlushTimeNanos << " " << stats.spillFlushTimeNanos
+          << " " << newGStats.spillFlushTimeNanos;
       ASSERT_EQ(
-          prevGStats.spillFillTimeUs + stats.spillFillTimeUs,
-          newGStats.spillFillTimeUs);
+          prevGStats.spillFillTimeNanos + stats.spillFillTimeNanos,
+          newGStats.spillFillTimeNanos);
       ASSERT_EQ(
-          prevGStats.spillSerializationTimeUs + stats.spillSerializationTimeUs,
-          newGStats.spillSerializationTimeUs);
+          prevGStats.spillSerializationTimeNanos +
+              stats.spillSerializationTimeNanos,
+          newGStats.spillSerializationTimeNanos);
       ASSERT_EQ(
           prevGStats.spillWrites + stats.spillWrites, newGStats.spillWrites);
 
@@ -1464,7 +1466,7 @@ TEST_P(AggregationOutputOnly, basic) {
       ASSERT_EQ(stats.spilledFiles, 1) << stats.toString();
       ASSERT_EQ(stats.spilledRows, expectedNumSpilledRows) << stats.toString();
     }
-    ASSERT_EQ(stats.spillSortTimeUs, 0);
+    ASSERT_EQ(stats.spillSortTimeNanos, 0);
   }
 }
 
@@ -1571,7 +1573,7 @@ TEST_P(OrderByOutputOnly, basic) {
       ASSERT_EQ(stats.spilledFiles, 1) << stats.toString();
       ASSERT_EQ(stats.spilledRows, expectedNumSpilledRows) << stats.toString();
     }
-    ASSERT_EQ(stats.spillSortTimeUs, 0);
+    ASSERT_EQ(stats.spillSortTimeNanos, 0);
   }
 }
 

From 8b75147a8183442b8dc4bb978aca446628490f26 Mon Sep 17 00:00:00 2001
From: Kevin Wilfong <kevinwilfong@meta.com>
Date: Wed, 21 Aug 2024 13:54:47 -0700
Subject: [PATCH 05/24] Cache the hash map in SubscriptUtil if a single map is
 reused with complex keys (#10414)

Summary:
Pull Request resolved: https://github.com/facebookincubator/velox/pull/10414

Today in SubscriptUtil, if the map passed in has primitive keys and the same MapVector is passed in
multiple times, we cache the hash maps for optimized lookups across batches.  If the map has
complex keys, and base MapVector has a single value, we construct a local hash map to optimize the
lookups within a batch.

This change merges the two approaches for maps with Complex keys, so if we see the same
Vector passed in multiple times where the base MapVector has a single value, we cache the hash
map so we don't need to reconstruct it for every batch.

In some cases we've seen this can significantly speed up Presto queries, particularly because the
cost of hashing complex types to construct the hash map can be fairly high.

We could go a step further and, like for maps with primitive keys, cache maps with complex keys
regardless of the number of values in the base MapVector, but I haven't seen any cases that would
benefit from this yet so I'm not sure what the tradeoffs in terms of memory and construction cost
would look like, so extending the original optimizations seems like a good starting point.

Reviewed By: Yuhta

Differential Revision: D59474490

fbshipit-source-id: 67da5f560b6522dbfa96af3774a4f9b1f738d7fa
---
 velox/functions/lib/SubscriptUtil.cpp         |  89 +++++-----
 velox/functions/lib/SubscriptUtil.h           |  89 +++++++---
 .../MapSubscriptCachingBenchmark.cpp          |  21 ++-
 .../prestosql/tests/ElementAtTest.cpp         | 157 +++++++++++++++++-
 velox/vector/fuzzer/VectorFuzzer.cpp          |   7 +-
 5 files changed, 289 insertions(+), 74 deletions(-)

diff --git a/velox/functions/lib/SubscriptUtil.cpp b/velox/functions/lib/SubscriptUtil.cpp
index 8c9b60ccdb0b2..51931384855f3 100644
--- a/velox/functions/lib/SubscriptUtil.cpp
+++ b/velox/functions/lib/SubscriptUtil.cpp
@@ -58,7 +58,7 @@ struct SimpleType<TypeKind::VARCHAR> {
 template <TypeKind kind>
 VectorPtr applyMapTyped(
     bool triggerCaching,
-    std::shared_ptr<LookupTableBase>& cachedLookupTablePtr,
+    std::shared_ptr<detail::LookupTableBase>& cachedLookupTablePtr,
     const SelectivityVector& rows,
     const VectorPtr& mapArg,
     const VectorPtr& indexArg,
@@ -66,14 +66,14 @@ VectorPtr applyMapTyped(
   static constexpr vector_size_t kMinCachedMapSize = 100;
   using TKey = typename TypeTraits<kind>::NativeType;
 
-  LookupTable<kind>* typedLookupTable = nullptr;
+  detail::LookupTable<TKey>* typedLookupTable = nullptr;
   if (triggerCaching) {
     if (!cachedLookupTablePtr) {
       cachedLookupTablePtr =
-          std::make_shared<LookupTable<kind>>(*context.pool());
+          std::make_shared<detail::LookupTable<TKey>>(*context.pool());
     }
 
-    typedLookupTable = cachedLookupTablePtr->typedTable<kind>();
+    typedLookupTable = cachedLookupTablePtr->typedTable<TKey>();
   }
 
   auto* pool = context.pool();
@@ -178,39 +178,13 @@ VectorPtr applyMapTyped(
       nullsBuilder.build(), indices, rows.end(), baseMap->mapValues());
 }
 
-// A flat vector of map keys, an index into that vector and an index into
-// the original map keys vector that may have encodings.
-struct MapKey {
-  const BaseVector* baseVector;
-  const vector_size_t baseIndex;
-  const vector_size_t index;
-
-  size_t hash() const {
-    return baseVector->hashValueAt(baseIndex);
-  }
-
-  bool operator==(const MapKey& other) const {
-    return baseVector->equalValueAt(
-        other.baseVector, baseIndex, other.baseIndex);
-  }
-
-  bool operator<(const MapKey& other) const {
-    return baseVector->compare(other.baseVector, baseIndex, other.baseIndex) <
-        0;
-  }
-};
-
-struct MapKeyHasher {
-  size_t operator()(const MapKey& key) const {
-    return key.hash();
-  }
-};
-
 VectorPtr applyMapComplexType(
     const SelectivityVector& rows,
     const VectorPtr& mapArg,
     const VectorPtr& indexArg,
-    exec::EvalCtx& context) {
+    exec::EvalCtx& context,
+    bool triggerCaching,
+    std::shared_ptr<detail::LookupTableBase>& cachedLookupTablePtr) {
   auto* pool = context.pool();
 
   // Use indices with the mapValues wrapped in a dictionary vector.
@@ -247,18 +221,42 @@ VectorPtr applyMapComplexType(
   // Fast path for the case of a single map. It may be constant or dictionary
   // encoded. Use hash table for quick search.
   if (baseMap->size() == 1) {
-    folly::F14FastSet<MapKey, MapKeyHasher> set;
-    auto numKeys = rawSizes[0];
-    set.reserve(numKeys * 1.3);
-    for (auto i = 0; i < numKeys; ++i) {
-      set.insert(MapKey{mapKeysBase, mapKeysIndices[i], i});
+    detail::ComplexKeyHashMap hashMap{detail::MapKeyAllocator(*pool)};
+    detail::ComplexKeyHashMap* hashMapPtr = &hashMap;
+
+    if (triggerCaching) {
+      if (!cachedLookupTablePtr) {
+        cachedLookupTablePtr =
+            std::make_shared<detail::LookupTable<void>>(*context.pool());
+      }
+
+      detail::LookupTable<void>* typedLookupTable =
+          cachedLookupTablePtr->typedTable<void>();
+
+      static constexpr vector_size_t kMapIndex = 0;
+
+      if (!typedLookupTable->containsMapAtIndex(kMapIndex)) {
+        typedLookupTable->ensureMapAtIndex(kMapIndex);
+      }
+
+      auto& map = typedLookupTable->getMapAtIndex(kMapIndex);
+      hashMapPtr = &map;
     }
+
+    if (hashMapPtr->empty()) {
+      auto numKeys = rawSizes[0];
+      hashMapPtr->reserve(numKeys * 1.3);
+      for (auto i = 0; i < numKeys; ++i) {
+        hashMapPtr->insert(detail::MapKey{mapKeysBase, mapKeysIndices[i], i});
+      }
+    }
+
     rows.applyToSelected([&](vector_size_t row) {
       VELOX_CHECK_EQ(0, mapIndices[row]);
 
       auto searchIndex = searchIndices[row];
-      auto it = set.find(MapKey{searchBase, searchIndex, row});
-      if (it != set.end()) {
+      auto it = hashMapPtr->find(detail::MapKey{searchBase, searchIndex, row});
+      if (it != hashMapPtr->end()) {
         rawIndices[row] = it->index;
       } else {
         nullsBuilder.setNull(row);
@@ -302,6 +300,8 @@ VectorPtr applyMapComplexType(
 
 } // namespace
 
+namespace detail {
+
 VectorPtr MapSubscript::applyMap(
     const SelectivityVector& rows,
     std::vector<VectorPtr>& args,
@@ -312,20 +312,20 @@ VectorPtr MapSubscript::applyMap(
   // Ensure map key type and second argument are the same.
   VELOX_CHECK(mapArg->type()->childAt(0)->equivalent(*indexArg->type()));
 
+  bool triggerCaching = shouldTriggerCaching(mapArg);
   if (indexArg->type()->isPrimitiveType()) {
-    bool triggerCaching = shouldTriggerCaching(mapArg);
-
     return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
         applyMapTyped,
         indexArg->typeKind(),
         triggerCaching,
-        const_cast<std::shared_ptr<LookupTableBase>&>(lookupTable_),
+        lookupTable_,
         rows,
         mapArg,
         indexArg,
         context);
   } else {
-    return applyMapComplexType(rows, mapArg, indexArg, context);
+    return applyMapComplexType(
+        rows, mapArg, indexArg, context, triggerCaching, lookupTable_);
   }
 }
 
@@ -369,5 +369,6 @@ const std::exception_ptr& negativeSubscriptError() {
   static std::exception_ptr error = makeNegativeSubscriptError();
   return error;
 }
+} // namespace detail
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SubscriptUtil.h b/velox/functions/lib/SubscriptUtil.h
index 18daf68e03a9c..2700d0c1bf070 100644
--- a/velox/functions/lib/SubscriptUtil.h
+++ b/velox/functions/lib/SubscriptUtil.h
@@ -30,28 +30,64 @@
 
 namespace facebook::velox::functions {
 
+namespace detail {
 // Below functions return a stock instance of each of the possible errors in
 // SubscriptImpl
 const std::exception_ptr& zeroSubscriptError();
 const std::exception_ptr& badSubscriptError();
 const std::exception_ptr& negativeSubscriptError();
 
-template <TypeKind kind>
+// A flat vector of map keys, an index into that vector and an index into
+// the original map keys vector that may have encodings.
+struct MapKey {
+  const BaseVector* baseVector;
+  const vector_size_t baseIndex;
+  const vector_size_t index;
+
+  size_t hash() const {
+    return baseVector->hashValueAt(baseIndex);
+  }
+
+  bool operator==(const MapKey& other) const {
+    return baseVector->equalValueAt(
+        other.baseVector, baseIndex, other.baseIndex);
+  }
+
+  bool operator<(const MapKey& other) const {
+    return baseVector->compare(other.baseVector, baseIndex, other.baseIndex) <
+        0;
+  }
+};
+
+struct MapKeyHasher {
+  size_t operator()(const MapKey& key) const {
+    return key.hash();
+  }
+};
+
+using MapKeyAllocator = memory::StlAllocator<detail::MapKey>;
+
+using ComplexKeyHashMap = folly::F14FastSet<
+    detail::MapKey,
+    detail::MapKeyHasher,
+    folly::f14::DefaultKeyEqual<detail::MapKey>,
+    MapKeyAllocator>;
+
+template <typename NativeType>
 class LookupTable;
 
 class LookupTableBase {
  public:
-  template <TypeKind kind>
-  LookupTable<kind>* typedTable() {
-    return static_cast<LookupTable<kind>*>(this);
+  template <typename NativeType>
+  LookupTable<NativeType>* typedTable() {
+    return static_cast<LookupTable<NativeType>*>(this);
   }
   virtual ~LookupTableBase() {}
 };
 
-template <TypeKind kind>
+// NativeType should by TypeTraits<TypeKind>::NativeType for the key's TypeKind.
+template <typename NativeType>
 class LookupTable : public LookupTableBase {
-  using key_t = typename TypeTraits<kind>::NativeType;
-
  public:
   LookupTable(memory::MemoryPool& pool)
       : pool_(pool),
@@ -75,11 +111,22 @@ class LookupTable : public LookupTableBase {
   }
 
  private:
-  using inner_allocator_t =
-      memory::StlAllocator<std::pair<key_t const, vector_size_t>>;
-
-  using inner_map_t = typename util::floating_point::
-      HashMapNaNAwareTypeTraits<key_t, vector_size_t, inner_allocator_t>::Type;
+  // If the NativeType is not void, we can materialize the key in memory
+  // directly, so we can use a HashMap keyed on the native value.  If it is void
+  // then we have to use MapKey as the key to wrap the Vector and avoid
+  // materializing the key in memory.
+  using inner_allocator_t = std::conditional_t<
+      std::is_same_v<NativeType, void>,
+      MapKeyAllocator,
+      memory::StlAllocator<std::pair<NativeType const, vector_size_t>>>;
+
+  using inner_map_t = std::conditional_t<
+      std::is_same_v<NativeType, void>,
+      ComplexKeyHashMap,
+      typename util::floating_point::HashMapNaNAwareTypeTraits<
+          NativeType,
+          vector_size_t,
+          inner_allocator_t>::Type>;
 
   using outer_allocator_t =
       memory::StlAllocator<std::pair<vector_size_t const, inner_map_t>>;
@@ -123,9 +170,8 @@ class MapSubscript {
       return false;
     }
 
-    if (!mapArg->type()->childAt(0)->isPrimitiveType() &&
-        !!mapArg->type()->childAt(0)->isBoolean()) {
-      // Disable caching if the key type is not primitive or is boolean.
+    if (mapArg->type()->childAt(0)->isBoolean()) {
+      // Disable caching if the key type is boolean.
       allowCaching_ = false;
       return false;
     }
@@ -158,6 +204,7 @@ class MapSubscript {
   // Materialized cached version of firstSeenMap_ used to optimize the lookup.
   mutable std::shared_ptr<LookupTableBase> lookupTable_;
 };
+} // namespace detail
 
 /// Generic subscript/element_at implementation for both array and map data
 /// types.
@@ -179,7 +226,7 @@ template <
 class SubscriptImpl : public exec::Subscript {
  public:
   explicit SubscriptImpl(bool allowCaching)
-      : mapSubscript_(MapSubscript(allowCaching)) {}
+      : mapSubscript_(detail::MapSubscript(allowCaching)) {}
 
   void apply(
       const SelectivityVector& rows,
@@ -286,7 +333,7 @@ class SubscriptImpl : public exec::Subscript {
       const auto adjustedIndex =
           adjustIndex(decodedIndices->valueAt<I>(0), isZeroSubscriptError);
       if (isZeroSubscriptError) {
-        context.setErrors(rows, zeroSubscriptError());
+        context.setErrors(rows, detail::zeroSubscriptError());
         allFailed = true;
       }
 
@@ -307,7 +354,7 @@ class SubscriptImpl : public exec::Subscript {
         const auto adjustedIndex =
             adjustIndex(originalIndex, isZeroSubscriptError);
         if (isZeroSubscriptError) {
-          context.setVeloxExceptionError(row, zeroSubscriptError());
+          context.setVeloxExceptionError(row, detail::zeroSubscriptError());
           return;
         }
         const auto elementIndex = getIndex(
@@ -372,7 +419,7 @@ class SubscriptImpl : public exec::Subscript {
           index += arraySize;
         }
       } else {
-        context.setVeloxExceptionError(row, negativeSubscriptError());
+        context.setVeloxExceptionError(row, detail::negativeSubscriptError());
         return -1;
       }
     }
@@ -383,7 +430,7 @@ class SubscriptImpl : public exec::Subscript {
       if constexpr (allowOutOfBound) {
         return -1;
       } else {
-        context.setVeloxExceptionError(row, badSubscriptError());
+        context.setVeloxExceptionError(row, detail::badSubscriptError());
         return -1;
       }
     }
@@ -394,7 +441,7 @@ class SubscriptImpl : public exec::Subscript {
   }
 
  private:
-  MapSubscript mapSubscript_;
+  detail::MapSubscript mapSubscript_;
 };
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/benchmarks/MapSubscriptCachingBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapSubscriptCachingBenchmark.cpp
index e46b9d01d66b3..63568002bb60a 100644
--- a/velox/functions/prestosql/benchmarks/MapSubscriptCachingBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/MapSubscriptCachingBenchmark.cpp
@@ -37,6 +37,7 @@ extern void registerSubscriptFunction(
 
 int main(int argc, char** argv) {
   folly::Init init(&argc, &argv);
+  memory::MemoryManager::testingSetInstance({});
 
   ExpressionBenchmarkBuilder benchmarkBuilder;
   facebook::velox::functions::prestosql::registerAllScalarFunctions();
@@ -53,7 +54,8 @@ int main(int argc, char** argv) {
     VectorFuzzer::Options options;
     options.vectorSize = 1000;
     options.containerLength = mapLength;
-    options.complexElementsMaxSize = 10000000000;
+    // Make sure it's big enough for nested complex types.
+    options.complexElementsMaxSize = baseVectorSize * mapLength * mapLength;
     options.containerVariableLength = false;
 
     VectorFuzzer fuzzer(options, pool);
@@ -112,6 +114,23 @@ int main(int argc, char** argv) {
   createSetsForType(INTEGER());
   createSetsForType(VARCHAR());
 
+  // For complex types, caching only applies if the Vector has a single constant
+  // value, so we only run with a baseVectorSize of 1.  Also, due to the
+  // cost of the cardinality explosion from having nested complex types, we
+  // limit the number of iterations to 100.
+  auto createSetsForComplexType = [&](const auto& keyType) {
+    createSet(MAP(keyType, INTEGER()), 10, 1, 100);
+
+    createSet(MAP(keyType, INTEGER()), 100, 1, 100);
+
+    createSet(MAP(keyType, INTEGER()), 1000, 1, 100);
+
+    createSet(MAP(keyType, INTEGER()), 10000, 1, 100);
+  };
+
+  createSetsForComplexType(ARRAY(BIGINT()));
+  createSetsForComplexType(MAP(INTEGER(), VARCHAR()));
+
   benchmarkBuilder.registerBenchmarks();
   benchmarkBuilder.testBenchmarks();
 
diff --git a/velox/functions/prestosql/tests/ElementAtTest.cpp b/velox/functions/prestosql/tests/ElementAtTest.cpp
index 384ab8e580705..1a7a6b8d003d2 100644
--- a/velox/functions/prestosql/tests/ElementAtTest.cpp
+++ b/velox/functions/prestosql/tests/ElementAtTest.cpp
@@ -143,7 +143,8 @@ class ElementAtTest : public FunctionBaseTest {
     auto keys = makeFlatVector<T>(std::vector<T>({kSNaN}));
     std::vector<VectorPtr> args = {inputMap, keys};
 
-    facebook::velox::functions::MapSubscript mapSubscriptWithCaching(true);
+    facebook::velox::functions::detail::MapSubscript mapSubscriptWithCaching(
+        true);
 
     auto checkStatus = [&](bool cachingEnabled,
                            bool materializedMapIsNull,
@@ -1030,7 +1031,7 @@ TEST_F(ElementAtTest, errorStatesArray) {
       [](auto row) { return row == 40; });
 }
 
-TEST_F(ElementAtTest, testCachingOptimzation) {
+TEST_F(ElementAtTest, testCachingOptimization) {
   std::vector<std::vector<std::pair<int64_t, std::optional<int64_t>>>>
       inputMapVectorData;
   inputMapVectorData.push_back({});
@@ -1068,7 +1069,8 @@ TEST_F(ElementAtTest, testCachingOptimzation) {
   auto keys = makeFlatVector<int64_t>({0, 0, 0});
   std::vector<VectorPtr> args = {inputMap, keys};
 
-  facebook::velox::functions::MapSubscript mapSubscriptWithCaching(true);
+  facebook::velox::functions::detail::MapSubscript mapSubscriptWithCaching(
+      true);
 
   auto checkStatus = [&](bool cachingEnabled,
                          bool materializedMapIsNull,
@@ -1100,8 +1102,7 @@ TEST_F(ElementAtTest, testCachingOptimzation) {
   // Test the cached map content.
   auto verfyCachedContent = [&]() {
     auto& cachedMapTyped =
-        *static_cast<
-             facebook::velox::functions::LookupTable<TypeKind::BIGINT>*>(
+        *static_cast<facebook::velox::functions::detail::LookupTable<int64_t>*>(
              mapSubscriptWithCaching.lookupTable().get())
              ->map();
 
@@ -1182,3 +1183,149 @@ TEST_F(ElementAtTest, floatingPointCornerCases) {
   testFloatingPointCornerCases<float>();
   testFloatingPointCornerCases<double>();
 }
+
+TEST_F(ElementAtTest, testCachingOptimizationComplexKey) {
+  std::vector<std::vector<int64_t>> keys;
+  std::vector<int64_t> values;
+  for (int i = 0; i < 999; i += 3) {
+    // [0, 1, 2] -> 1000
+    // [3, 4, 5] -> 1003
+    // ...
+    keys.push_back({i, i + 1, i + 2});
+    values.push_back(i + 1000);
+  }
+
+  // Make a dummy eval context.
+  exec::ExprSet exprSet({}, &execCtx_);
+  auto inputs = makeRowVector({});
+  exec::EvalCtx evalCtx(&execCtx_, &exprSet, inputs.get());
+
+  SelectivityVector rows(1);
+  auto keysVector = makeArrayVector<int64_t>(keys);
+  auto valuesVector = makeFlatVector<int64_t>(values);
+  auto inputMap = makeMapVector({0}, keysVector, valuesVector);
+
+  auto inputKeys = makeArrayVector<int64_t>({{0, 1, 2}});
+  std::vector<VectorPtr> args{inputMap, inputKeys};
+
+  facebook::velox::functions::detail::MapSubscript mapSubscriptWithCaching(
+      true);
+
+  auto checkStatus = [&](bool cachingEnabled,
+                         bool materializedMapIsNull,
+                         const VectorPtr& firtSeen) {
+    EXPECT_EQ(cachingEnabled, mapSubscriptWithCaching.cachingEnabled());
+    EXPECT_EQ(firtSeen, mapSubscriptWithCaching.firstSeenMap());
+    EXPECT_EQ(
+        materializedMapIsNull,
+        nullptr == mapSubscriptWithCaching.lookupTable());
+  };
+
+  // Initial state.
+  checkStatus(true, true, nullptr);
+
+  auto result1 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  // Nothing has been materialized yet since the input is seen only once.
+  checkStatus(true, true, args[0]);
+
+  auto result2 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(true, false, args[0]);
+
+  auto result3 = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(true, false, args[0]);
+
+  // all the result should be the same.
+  test::assertEqualVectors(result1, result2);
+  test::assertEqualVectors(result2, result3);
+
+  // Test the cached map content.
+  auto verfyCachedContent = [&]() {
+    auto& cachedMap = mapSubscriptWithCaching.lookupTable()
+                          ->typedTable<void>()
+                          ->getMapAtIndex(0);
+
+    for (int i = 0; i < keysVector->size(); i += 3) {
+      EXPECT_NE(
+          cachedMap.end(),
+          cachedMap.find(facebook::velox::functions::detail::MapKey{
+              keysVector.get(), 0, 0}));
+    }
+  };
+
+  verfyCachedContent();
+  // Pass different map with same base.
+  {
+    auto dictInput = BaseVector::wrapInDictionary(
+        nullptr, makeIndices({0, 0, 0}), 1, inputMap);
+
+    SelectivityVector rows(3);
+    std::vector<VectorPtr> args{
+        dictInput, makeArrayVector<int64_t>({{0, 1, 2}, {0, 1, 2}, {0, 1, 2}})};
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    // Last seen map will keep pointing to the original map since both have
+    // the same base.
+    checkStatus(true, false, inputMap);
+
+    auto expectedResult = makeFlatVector<int64_t>({1000, 1000, 1000});
+    test::assertEqualVectors(expectedResult, result);
+    verfyCachedContent();
+  }
+
+  {
+    auto constantInput = BaseVector::wrapInConstant(3, 0, inputMap);
+
+    SelectivityVector rows(3);
+    std::vector<VectorPtr> args{
+        constantInput,
+        makeArrayVector<int64_t>({{0, 1, 2}, {0, 1, 2}, {0, 1, 2}})};
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    // Last seen map will keep pointing to the original map since both have
+    // the same base.
+    checkStatus(true, false, inputMap);
+
+    auto expectedResult = makeFlatVector<int64_t>({1000, 1000, 1000});
+    test::assertEqualVectors(expectedResult, result);
+    verfyCachedContent();
+  }
+
+  // Pass a different map, caching will be disabled.
+  {
+    args[0] = makeMapVector({0}, keysVector, valuesVector);
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(false, true, nullptr);
+    test::assertEqualVectors(result, result1);
+  }
+
+  {
+    args[0] = makeMapVector({0}, keysVector, valuesVector);
+    auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+    checkStatus(false, true, nullptr);
+    test::assertEqualVectors(result, result1);
+  }
+
+  for (int i = 0; i < 999; i += 3) {
+    // [0, 1, 2] -> 0
+    // [2, 3, 4] -> 1
+    // ...
+    keys.push_back({i * 2, i * 2 + 1, i * 2 + 2});
+    values.push_back(i);
+  }
+
+  for (int i = 0; i < 30; i += 3) {
+    // [0, 1, 2] -> 0
+    // [3, 4, 5] -> 3
+    // ...
+    keys.push_back({i, i + 1, i + 2});
+    values.push_back(i);
+  }
+
+  args[0] = makeMapVector({0, 333, 666}, keysVector, valuesVector);
+  auto resultWithMoreVectors =
+      mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(false, true, nullptr);
+
+  auto resultWithMoreVectors1 =
+      mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  checkStatus(false, true, nullptr);
+  test::assertEqualVectors(resultWithMoreVectors, resultWithMoreVectors1);
+}
diff --git a/velox/vector/fuzzer/VectorFuzzer.cpp b/velox/vector/fuzzer/VectorFuzzer.cpp
index 7708b56b60015..d8fcd38d180cb 100644
--- a/velox/vector/fuzzer/VectorFuzzer.cpp
+++ b/velox/vector/fuzzer/VectorFuzzer.cpp
@@ -135,9 +135,10 @@ Timestamp randTimestamp(FuzzerGenerator& rng, VectorFuzzer::Options opts) {
 size_t getElementsVectorLength(
     const VectorFuzzer::Options& opts,
     vector_size_t size) {
-  if (opts.containerVariableLength == false &&
-      size * opts.containerLength > opts.complexElementsMaxSize) {
-    VELOX_USER_FAIL(
+  if (!opts.containerVariableLength) {
+    VELOX_USER_CHECK_LE(
+        size * opts.containerLength,
+        opts.complexElementsMaxSize,
         "Requested fixed opts.containerVariableLength can't be satisfied: "
         "increase opts.complexElementsMaxSize, reduce opts.containerLength"
         " or make opts.containerVariableLength=true");

From 2796200da36c7d033d45066e00ed09e96eb6c614 Mon Sep 17 00:00:00 2001
From: Ke <ke.404notfound@gmail.com>
Date: Thu, 22 Aug 2024 01:04:48 -0700
Subject: [PATCH 06/24] Add complex type inputs to array_except,
 array_intersect and arrays_overlap (#10743)

Summary: Pull Request resolved: https://github.com/facebookincubator/velox/pull/10743

Reviewed By: kevinwilfong

Differential Revision: D61246379

Pulled By: kewang1024

fbshipit-source-id: 1f2fb793a43e18abe51bfba97ba1558b8204c563
---
 .../prestosql/ArrayIntersectExcept.cpp        | 125 ++++++++++++++----
 .../prestosql/tests/ArrayExceptTest.cpp       |  64 +++++++++
 .../prestosql/tests/ArrayIntersectTest.cpp    |  59 +++++++++
 .../prestosql/tests/ArraysOverlapTest.cpp     |  65 +++++++++
 velox/type/Type.h                             |  64 +++++++++
 5 files changed, 350 insertions(+), 27 deletions(-)

diff --git a/velox/functions/prestosql/ArrayIntersectExcept.cpp b/velox/functions/prestosql/ArrayIntersectExcept.cpp
index c13c812914dc3..2dfcef7f3feac 100644
--- a/velox/functions/prestosql/ArrayIntersectExcept.cpp
+++ b/velox/functions/prestosql/ArrayIntersectExcept.cpp
@@ -20,12 +20,23 @@
 
 namespace facebook::velox::functions {
 namespace {
+constexpr vector_size_t kInitialSetSize{128};
+
 template <typename T>
 struct SetWithNull {
   SetWithNull(vector_size_t initialSetSize = kInitialSetSize) {
     set.reserve(initialSetSize);
   }
 
+  bool insert(const DecodedVector* decodedElements, vector_size_t offset) {
+    return set.insert(decodedElements->valueAt<T>(offset)).second;
+  }
+
+  size_t count(const DecodedVector* decodedElements, vector_size_t offset)
+      const {
+    return set.count(decodedElements->valueAt<T>(offset));
+  }
+
   void reset() {
     set.clear();
     hasNull = false;
@@ -37,7 +48,65 @@ struct SetWithNull {
 
   util::floating_point::HashSetNaNAware<T> set;
   bool hasNull{false};
-  static constexpr vector_size_t kInitialSetSize{128};
+};
+
+struct ComplexTypeEntry {
+  const uint64_t hash;
+  const BaseVector* baseVector;
+  const vector_size_t index;
+};
+
+template <>
+struct SetWithNull<ComplexTypeEntry> {
+  struct Hash {
+    size_t operator()(const ComplexTypeEntry& entry) const {
+      return entry.hash;
+    }
+  };
+
+  struct EqualTo {
+    bool operator()(const ComplexTypeEntry& left, const ComplexTypeEntry& right)
+        const {
+      return left.baseVector
+          ->equalValueAt(
+              right.baseVector,
+              left.index,
+              right.index,
+              CompareFlags::NullHandlingMode::kNullAsValue)
+          .value();
+    }
+  };
+
+  folly::F14FastSet<ComplexTypeEntry, Hash, EqualTo> set;
+  bool hasNull{false};
+
+  SetWithNull(vector_size_t initialSetSize = kInitialSetSize) {
+    set.reserve(initialSetSize);
+  }
+
+  bool insert(const DecodedVector* decodedElements, vector_size_t offset) {
+    const auto vector = decodedElements->base();
+    const auto index = decodedElements->index(offset);
+    const uint64_t hash = vector->hashValueAt(index);
+    return set.insert(ComplexTypeEntry{hash, vector, index}).second;
+  }
+
+  size_t count(const DecodedVector* decodedElements, vector_size_t offset)
+      const {
+    const auto vector = decodedElements->base();
+    const auto index = decodedElements->index(offset);
+    const uint64_t hash = vector->hashValueAt(index);
+    return set.count(ComplexTypeEntry{hash, vector, index});
+  }
+
+  void reset() {
+    set.clear();
+    hasNull = false;
+  }
+
+  bool empty() const {
+    return !hasNull && set.empty();
+  }
 };
 
 // Generates a set based on the elements of an ArrayVector. Note that we take
@@ -57,7 +126,7 @@ void generateSet(
     if (arrayElements->isNullAt(i)) {
       rightSet.hasNull = true;
     } else {
-      rightSet.set.insert(arrayElements->template valueAt<T>(i));
+      rightSet.insert(arrayElements, i);
     }
   }
 }
@@ -186,19 +255,17 @@ class ArrayIntersectExceptFunction : public exec::VectorFunction {
             }
           }
         } else {
-          auto val = decodedLeftElements->valueAt<T>(i);
           // For array_intersect, add the element if it is found (not found
           // for array_except) in the right-hand side, and wasn't added already
           // (check outputSet).
           bool addValue = false;
           if constexpr (isIntersect) {
-            addValue = rightSet.set.count(val) > 0;
+            addValue = rightSet.count(decodedLeftElements, i) > 0;
           } else {
-            addValue = rightSet.set.count(val) == 0;
+            addValue = rightSet.count(decodedLeftElements, i) == 0;
           }
           if (addValue) {
-            auto it = outputSet.set.insert(val);
-            if (it.second) {
+            if (outputSet.insert(decodedLeftElements, i)) {
               rawNewIndices[indicesCursor++] = i;
             }
           }
@@ -294,7 +361,7 @@ class ArraysOverlapFunction : public exec::VectorFunction {
           hasNull = true;
           continue;
         }
-        if (rightSet.set.count(decodedLeftElements->valueAt<T>(i)) > 0) {
+        if (rightSet.count(decodedLeftElements, i) > 0) {
           // Found an overlapping element. Add to result set.
           resultBoolVector->set(row, true);
           return;
@@ -396,7 +463,10 @@ SetWithNull<T> validateConstantVectorAndGenerateSet(
 template <bool isIntersect, TypeKind kind>
 std::shared_ptr<exec::VectorFunction> createTypedArraysIntersectExcept(
     const std::vector<exec::VectorFunctionArg>& inputArgs) {
-  using T = typename TypeTraits<kind>::NativeType;
+  using T = std::conditional_t<
+      TypeTraits<kind>::isPrimitiveType,
+      typename TypeTraits<kind>::NativeType,
+      ComplexTypeEntry>;
 
   VELOX_CHECK_EQ(inputArgs.size(), 2);
   BaseVector* rhs = inputArgs[1].constantValue.get();
@@ -424,7 +494,7 @@ std::shared_ptr<exec::VectorFunction> createArrayIntersect(
   validateMatchingArrayTypes(inputArgs, name, 2);
   auto elementType = inputArgs.front().type->childAt(0);
 
-  return VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+  return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
       createTypedArraysIntersectExcept,
       /* isIntersect */ true,
       elementType->kind(),
@@ -438,7 +508,7 @@ std::shared_ptr<exec::VectorFunction> createArrayExcept(
   validateMatchingArrayTypes(inputArgs, name, 2);
   auto elementType = inputArgs.front().type->childAt(0);
 
-  return VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+  return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
       createTypedArraysIntersectExcept,
       /* isIntersect */ false,
       elementType->kind(),
@@ -446,18 +516,15 @@ std::shared_ptr<exec::VectorFunction> createArrayExcept(
 }
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
-    const std::string& returnTypeTemplate) {
-  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-  for (const auto& type : exec::primitiveTypeNames()) {
-    signatures.push_back(
-        exec::FunctionSignatureBuilder()
-            .returnType(
-                fmt::format(fmt::runtime(returnTypeTemplate.c_str()), type))
-            .argumentType(fmt::format("array({})", type))
-            .argumentType(fmt::format("array({})", type))
-            .build());
-  }
-  return signatures;
+    const std::string& returnType) {
+  return std::vector<std::shared_ptr<exec::FunctionSignature>>{
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType(returnType)
+          .argumentType("array(T)")
+          .argumentType("array(T)")
+          .build(),
+  };
 }
 
 template <TypeKind kind>
@@ -466,7 +533,11 @@ const std::shared_ptr<exec::VectorFunction> createTypedArraysOverlap(
   VELOX_CHECK_EQ(inputArgs.size(), 2);
   auto left = inputArgs[0].constantValue.get();
   auto right = inputArgs[1].constantValue.get();
-  using T = typename TypeTraits<kind>::NativeType;
+  using T = std::conditional_t<
+      TypeTraits<kind>::isPrimitiveType,
+      typename TypeTraits<kind>::NativeType,
+      ComplexTypeEntry>;
+
   if (left == nullptr && right == nullptr) {
     return std::make_shared<ArraysOverlapFunction<T>>();
   }
@@ -484,7 +555,7 @@ std::shared_ptr<exec::VectorFunction> createArraysOverlapFunction(
   validateMatchingArrayTypes(inputArgs, name, 2);
   auto elementType = inputArgs.front().type->childAt(0);
 
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+  return VELOX_DYNAMIC_TYPE_DISPATCH(
       createTypedArraysOverlap, elementType->kind(), inputArgs);
 }
 } // namespace
@@ -496,11 +567,11 @@ VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
 
 VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
     udf_array_intersect,
-    signatures("array({})"),
+    signatures("array(T)"),
     createArrayIntersect);
 
 VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
     udf_array_except,
-    signatures("array({})"),
+    signatures("array(T)"),
     createArrayExcept);
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/ArrayExceptTest.cpp b/velox/functions/prestosql/tests/ArrayExceptTest.cpp
index aef7de5d2e161..2a23e14788f3f 100644
--- a/velox/functions/prestosql/tests/ArrayExceptTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayExceptTest.cpp
@@ -24,6 +24,9 @@ using namespace facebook::velox::functions::test;
 
 namespace {
 
+template <typename TKey, typename TValue>
+using Pair = std::pair<TKey, std::optional<TValue>>;
+
 class ArrayExceptTest : public FunctionBaseTest {
  protected:
   void testExpr(
@@ -278,6 +281,67 @@ TEST_F(ArrayExceptTest, varbinary) {
   testExpr(expected, "array_except(c0, c1)", {right, left});
 }
 
+TEST_F(ArrayExceptTest, complexTypeArray) {
+  auto left = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [1, 2, 3], [null, null]]",
+      "[[1], [2], []]",
+      "[[1, null, 3]]",
+      "[[1, null, 3]]",
+  });
+
+  auto right = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[1]]",
+      "[[1, null, 3], [1, 2]]",
+      "[[1, null, 3, null]]",
+  });
+
+  auto expected = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [null, null]]",
+      "[[2], []]",
+      "[]",
+      "[[1, null, 3]]",
+  });
+  testExpr(expected, "array_except(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayExceptTest, complexTypeMap) {
+  std::vector<Pair<StringView, int64_t>> a{{"blue", 1}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> b{{"blue", 2}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> c{{"green", std::nullopt}};
+  std::vector<Pair<StringView, int64_t>> d{{"yellow", 4}, {"purple", 5}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> leftData{
+      {b, a}, {b}, {c, a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> rightData{
+      {a, b}, {}, {a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> expectedData{
+      {}, {b}, {c}};
+
+  auto left = makeArrayOfMapVector<StringView, int64_t>(leftData);
+  auto right = makeArrayOfMapVector<StringView, int64_t>(rightData);
+  auto expected = makeArrayOfMapVector<StringView, int64_t>(expectedData);
+
+  testExpr(expected, "array_except(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayExceptTest, complexTypeRow) {
+  RowTypePtr rowType = ROW({INTEGER(), VARCHAR()});
+
+  using ArrayOfRow = std::vector<std::optional<std::tuple<int, std::string>>>;
+  std::vector<ArrayOfRow> leftData = {
+      {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+      {{{1, "red"}}, {{2, "blue"}}, {}},
+      {{{1, "red"}}, std::nullopt, std::nullopt}};
+  std::vector<ArrayOfRow> rightData = {
+      {{{2, "blue"}}, {{1, "red"}}}, {{}, {{1, "green"}}}, {{{1, "red"}}}};
+  std::vector<ArrayOfRow> expectedData = {
+      {{{3, "green"}}}, {{{1, "red"}}, {{2, "blue"}}}, {std::nullopt}};
+  auto left = makeArrayOfRowVector(leftData, rowType);
+  auto right = makeArrayOfRowVector(rightData, rowType);
+  auto expected = makeArrayOfRowVector(expectedData, rowType);
+  testExpr(expected, "array_except(c0, c1)", {left, right});
+}
+
 // When one of the arrays is constant.
 TEST_F(ArrayExceptTest, constant) {
   auto array1 = makeNullableArrayVector<int32_t>({
diff --git a/velox/functions/prestosql/tests/ArrayIntersectTest.cpp b/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
index 8260f9fbdf9c2..3ae43b8acb815 100644
--- a/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayIntersectTest.cpp
@@ -24,6 +24,9 @@ using namespace facebook::velox::functions::test;
 
 namespace {
 
+template <typename TKey, typename TValue>
+using Pair = std::pair<TKey, std::optional<TValue>>;
+
 class ArrayIntersectTest : public FunctionBaseTest {
  protected:
   void testExpr(
@@ -257,6 +260,62 @@ TEST_F(ArrayIntersectTest, varbinary) {
   testExpr(expected, "array_intersect(c0, c1)", {right, left});
 }
 
+TEST_F(ArrayIntersectTest, complexTypeArray) {
+  auto left = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [1, 2, 3], [null, null]]",
+      "[[1], [2], []]",
+      "[[1, null, 3]]",
+      "[[1, null, 3]]",
+  });
+
+  auto right = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[1]]",
+      "[[1, null, 3], [1, 2]]",
+      "[[1, null, 3, null]]",
+  });
+
+  auto expected = makeNestedArrayVectorFromJson<int32_t>(
+      {"[[1, 2, 3]]", "[[1]]", "[[1, null, 3]]", "[]"});
+  testExpr(expected, "array_intersect(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayIntersectTest, complexTypeMap) {
+  std::vector<Pair<StringView, int64_t>> a{{"blue", 1}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> b{{"green", std::nullopt}};
+  std::vector<Pair<StringView, int64_t>> c{{"yellow", 4}, {"purple", 5}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> leftData{
+      {b, a}, {b}, {c, a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> rightData{
+      {a, b}, {}, {a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> expectedData{
+      {b, a}, {}, {a}};
+
+  auto left = makeArrayOfMapVector<StringView, int64_t>(leftData);
+  auto right = makeArrayOfMapVector<StringView, int64_t>(rightData);
+  auto expected = makeArrayOfMapVector<StringView, int64_t>(expectedData);
+
+  testExpr(expected, "array_intersect(c0, c1)", {left, right});
+}
+
+TEST_F(ArrayIntersectTest, complexTypeRow) {
+  RowTypePtr rowType = ROW({INTEGER(), VARCHAR()});
+
+  using ArrayOfRow = std::vector<std::optional<std::tuple<int, std::string>>>;
+  std::vector<ArrayOfRow> leftData = {
+      {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+      {{{1, "red"}}, {{2, "blue"}}, {}},
+      {{{1, "red"}}, std::nullopt, std::nullopt}};
+  std::vector<ArrayOfRow> rightData = {
+      {{{2, "blue"}}, {{1, "red"}}}, {{}, {{1, "green"}}}, {{{1, "red"}}}};
+  std::vector<ArrayOfRow> expectedData = {
+      {{{1, "red"}}, {{2, "blue"}}}, {{}}, {{{1, "red"}}}};
+  auto left = makeArrayOfRowVector(leftData, rowType);
+  auto right = makeArrayOfRowVector(rightData, rowType);
+  auto expected = makeArrayOfRowVector(expectedData, rowType);
+  testExpr(expected, "array_intersect(c0, c1)", {left, right});
+}
+
 // When one of the arrays is constant.
 TEST_F(ArrayIntersectTest, constant) {
   auto array1 = makeNullableArrayVector<int32_t>({
diff --git a/velox/functions/prestosql/tests/ArraysOverlapTest.cpp b/velox/functions/prestosql/tests/ArraysOverlapTest.cpp
index 002a6175cfcc5..002490be3ab8a 100644
--- a/velox/functions/prestosql/tests/ArraysOverlapTest.cpp
+++ b/velox/functions/prestosql/tests/ArraysOverlapTest.cpp
@@ -23,6 +23,9 @@ using namespace facebook::velox::test;
 using namespace facebook::velox::functions::test;
 
 namespace {
+template <typename TKey, typename TValue>
+using Pair = std::pair<TKey, std::optional<TValue>>;
+
 class ArraysOverlapTest : public FunctionBaseTest {
  protected:
   void testExpr(
@@ -210,6 +213,68 @@ TEST_F(ArraysOverlapTest, longStrings) {
   testExpr(expected, "arrays_overlap(C1, C0)", {array1, array2});
 }
 
+TEST_F(ArraysOverlapTest, complexTypeArray) {
+  auto left = makeNestedArrayVectorFromJson<int32_t>({
+      "[null, [1, 2, 3], [null, null]]",
+      "[[1], [2], []]",
+      "[[1, null, 3]]",
+      "[[1, null, 3]]",
+      "[null]",
+  });
+
+  auto right = makeNestedArrayVectorFromJson<int32_t>({
+      "[[1, 2, 3]]",
+      "[[1]]",
+      "[[1, 2]]",
+      "[[1, null, 3]]",
+      "[[]]",
+  });
+
+  auto expected =
+      makeNullableFlatVector<bool>({true, true, false, true, std::nullopt});
+  testExpr(expected, "arrays_overlap(c0, c1)", {left, right});
+}
+
+TEST_F(ArraysOverlapTest, complexTypeMap) {
+  std::vector<Pair<StringView, int64_t>> a{{"blue", 1}, {"red", 2}};
+  std::vector<Pair<StringView, int64_t>> b{{"green", std::nullopt}};
+  std::vector<Pair<StringView, int64_t>> c{{"yellow", 4}, {"purple", 5}};
+
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> leftData{
+      {b, a}, {b}, {c, a}};
+  std::vector<std::vector<std::vector<Pair<StringView, int64_t>>>> rightData{
+      {a, b}, {}, {b}};
+
+  auto left = makeArrayOfMapVector<StringView, int64_t>(leftData);
+  auto right = makeArrayOfMapVector<StringView, int64_t>(rightData);
+  auto expected = makeNullableFlatVector<bool>({true, false, false});
+
+  testExpr(expected, "arrays_overlap(c0, c1)", {left, right});
+}
+
+TEST_F(ArraysOverlapTest, complexTypeRow) {
+  RowTypePtr rowType = ROW({INTEGER(), VARCHAR()});
+
+  using ArrayOfRow = std::vector<std::optional<std::tuple<int, std::string>>>;
+  std::vector<ArrayOfRow> leftData = {
+      {{{1, "red"}}, {{2, "blue"}}, {{3, "green"}}},
+      {{{1, "red"}}, {{2, "blue"}}, std::nullopt},
+      {{{1, "red"}}, std::nullopt, std::nullopt},
+      {{{1, "red"}}, {{}}, {{}}}};
+  std::vector<ArrayOfRow> rightData = {
+      {{{2, "blue"}}, {{1, "red"}}},
+      {{{1, "green"}}},
+      {{{1, "red"}}},
+      {{{2, "red"}}}};
+
+  auto left = makeArrayOfRowVector(leftData, rowType);
+  auto right = makeArrayOfRowVector(rightData, rowType);
+  auto expected =
+      makeNullableFlatVector<bool>({true, std::nullopt, true, false});
+
+  testExpr(expected, "arrays_overlap(c0, c1)", {left, right});
+}
+
 //// When one of the arrays is constant.
 TEST_F(ArraysOverlapTest, constant) {
   auto array1 = makeNullableArrayVector<int32_t>({
diff --git a/velox/type/Type.h b/velox/type/Type.h
index 8a004dec043a8..b7bc6bbdbd3d7 100644
--- a/velox/type/Type.h
+++ b/velox/type/Type.h
@@ -1502,6 +1502,70 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
     }                                                                    \
   }()
 
+#define VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(TEMPLATE_FUNC, T, typeKind, ...) \
+  [&]() {                                                                     \
+    switch (typeKind) {                                                       \
+      case ::facebook::velox::TypeKind::BOOLEAN: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::BOOLEAN>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::INTEGER: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::INTEGER>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::TINYINT: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::TINYINT>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::SMALLINT: {                           \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::SMALLINT>(       \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::BIGINT: {                             \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::BIGINT>(         \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::HUGEINT: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::HUGEINT>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::REAL: {                               \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::REAL>(           \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::DOUBLE: {                             \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::DOUBLE>(         \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::VARCHAR: {                            \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::VARCHAR>(        \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::VARBINARY: {                          \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::VARBINARY>(      \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::TIMESTAMP: {                          \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::TIMESTAMP>(      \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::MAP: {                                \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::MAP>(            \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::ARRAY: {                              \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::ARRAY>(          \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      case ::facebook::velox::TypeKind::ROW: {                                \
+        return TEMPLATE_FUNC<T, ::facebook::velox::TypeKind::ROW>(            \
+            __VA_ARGS__);                                                     \
+      }                                                                       \
+      default:                                                                \
+        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind)); \
+    }                                                                         \
+  }()
+
 #define VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(TEMPLATE_FUNC, typeKind, ...)   \
   [&]() {                                                                      \
     if ((typeKind) == ::facebook::velox::TypeKind::UNKNOWN) {                  \

From 024d10d5dfc513b455423a2632a09b4501356e02 Mon Sep 17 00:00:00 2001
From: Ke <ke.404notfound@gmail.com>
Date: Thu, 22 Aug 2024 01:23:23 -0700
Subject: [PATCH 07/24] Support UNKNOWN type in map_concat function (#10795)

Summary: Pull Request resolved: https://github.com/facebookincubator/velox/pull/10795

Reviewed By: zacw7

Differential Revision: D61609911

Pulled By: kewang1024

fbshipit-source-id: ea9faa297cf70c7206f530d5b861dc15c4c7b9fd
---
 velox/functions/lib/MapConcat.cpp           |  2 +-
 velox/functions/lib/tests/MapConcatTest.cpp | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/velox/functions/lib/MapConcat.cpp b/velox/functions/lib/MapConcat.cpp
index 81c415f693c3e..aac38fbc93154 100644
--- a/velox/functions/lib/MapConcat.cpp
+++ b/velox/functions/lib/MapConcat.cpp
@@ -157,7 +157,7 @@ class MapConcatFunction : public exec::VectorFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K,V), map(K,V), ... -> map(K,V)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V")
                 .returnType("map(K,V)")
                 .argumentType("map(K,V)")
diff --git a/velox/functions/lib/tests/MapConcatTest.cpp b/velox/functions/lib/tests/MapConcatTest.cpp
index 9a46d90b5c946..c269391e1252c 100644
--- a/velox/functions/lib/tests/MapConcatTest.cpp
+++ b/velox/functions/lib/tests/MapConcatTest.cpp
@@ -283,3 +283,14 @@ TEST_F(MapConcatTest, nullEntry) {
   ASSERT_EQ(result->size(), 1);
   EXPECT_EQ(result->sizeAt(0), 0);
 }
+
+TEST_F(MapConcatTest, unknownType) {
+  // MAP_CONCAT(MAP[], MAP[])
+  auto emptyMapVector =
+      VectorTestBase::makeMapVector<UnknownValue, UnknownValue>({{}});
+  auto expectedMap =
+      VectorTestBase::makeMapVector<UnknownValue, UnknownValue>({{}});
+  auto result = evaluate(
+      "map_concat(c0, c1)", makeRowVector({emptyMapVector, emptyMapVector}));
+  facebook::velox::test::assertEqualVectors(expectedMap, result);
+}

From 9387a9d49944cc0b7419251e1a22a884ed1135ce Mon Sep 17 00:00:00 2001
From: Jialiang Tan <jacob.jialiang.tan@gmail.com>
Date: Thu, 22 Aug 2024 03:08:17 -0700
Subject: [PATCH 08/24] Let shrinkCapacity not shrink free cap (#10780)

Summary:
Shrinking free capacity when calling global shrinkCapacity method does not help with system memory pressure. Remove the free capacity shrink at the beginning of the method to help with actual memory pressure release as this method is only called by push back mechanism when there is memory pressure.

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10780

Reviewed By: xiaoxmeng

Differential Revision: D61496392

Pulled By: tanjialiang

fbshipit-source-id: a178f45c904ba3b21af3128d19beedf47360119a
---
 velox/common/memory/MemoryArbitrator.h        |  26 ++-
 velox/common/memory/SharedArbitrator.cpp      |  39 ++---
 .../memory/tests/MemoryArbitratorTest.cpp     |  24 ---
 .../memory/tests/MockSharedArbitratorTest.cpp | 155 +++---------------
 4 files changed, 61 insertions(+), 183 deletions(-)

diff --git a/velox/common/memory/MemoryArbitrator.h b/velox/common/memory/MemoryArbitrator.h
index d4b266208f4a1..20b50e6012886 100644
--- a/velox/common/memory/MemoryArbitrator.h
+++ b/velox/common/memory/MemoryArbitrator.h
@@ -126,15 +126,23 @@ class MemoryArbitrator {
   /// pool. The function returns the actual freed capacity from 'pool'.
   virtual uint64_t shrinkCapacity(MemoryPool* pool, uint64_t targetBytes) = 0;
 
-  /// Invoked by the memory manager to shrink memory capacity from memory pools
-  /// by reclaiming free and used memory. The freed memory capacity is given
-  /// back to the arbitrator.  If 'targetBytes' is zero, then try to reclaim all
-  /// the memory from 'pools'. The function returns the actual freed memory
-  /// capacity in bytes. If 'allowSpill' is true, it reclaims the used memory by
-  /// spilling. If 'allowAbort' is true, it reclaims the used memory by aborting
-  /// the queries with the most memory usage. If both are true, it first
-  /// reclaims the used memory by spilling and then abort queries to reach the
-  /// reclaim target.
+  /// Invoked by the memory manager to globally shrink memory from
+  /// memory pools by reclaiming only used memory, to reduce system memory
+  /// pressure. The freed memory capacity is given back to the arbitrator.  If
+  /// 'targetBytes' is zero, then try to reclaim all the memory from 'pools'.
+  /// The function returns the actual freed memory capacity in bytes. If
+  /// 'allowSpill' is true, it reclaims the used memory by spilling. If
+  /// 'allowAbort' is true, it reclaims the used memory by aborting the queries
+  /// with the most memory usage. If both are true, it first reclaims the used
+  /// memory by spilling and then abort queries to reach the reclaim target.
+  ///
+  /// NOTE: The actual reclaimed used memory (hence system memory) may be less
+  /// than 'targetBytes' due to the accounting of free capacity reclaimed. This
+  /// is okay because when this method is called, system is normally under
+  /// memory pressure, and there normally isn't much free capacity to reclaim.
+  /// So the reclaimed used memory in this case should be very close to
+  /// 'targetBytes' if enough used memory is reclaimable. We should improve this
+  /// in the future.
   virtual uint64_t shrinkCapacity(
       uint64_t targetBytes,
       bool allowSpill = true,
diff --git a/velox/common/memory/SharedArbitrator.cpp b/velox/common/memory/SharedArbitrator.cpp
index fc785576c9e2d..cd51312f1bcf4 100644
--- a/velox/common/memory/SharedArbitrator.cpp
+++ b/velox/common/memory/SharedArbitrator.cpp
@@ -496,37 +496,38 @@ uint64_t SharedArbitrator::shrinkCapacity(
   ArbitrationOperation op(requestBytes);
   ScopedArbitration scopedArbitration(this, &op);
 
-  uint64_t fastReclaimTargetBytes =
-      std::max(memoryPoolTransferCapacity_, requestBytes);
-
   std::lock_guard<std::shared_mutex> exclusiveLock(arbitrationLock_);
   getCandidates(&op);
-  uint64_t freedBytes =
-      reclaimFreeMemoryFromCandidates(&op, fastReclaimTargetBytes, false);
-  auto freeGuard = folly::makeGuard([&]() {
-    // Returns the freed memory capacity back to the arbitrator.
-    if (freedBytes > 0) {
-      incrementFreeCapacity(freedBytes);
-    }
-  });
-  if (freedBytes >= op.requestBytes) {
-    return freedBytes;
-  }
+  uint64_t unreturnedFreedBytes{0};
+  uint64_t totalFreedBytes{0};
+
   RECORD_METRIC_VALUE(kMetricArbitratorSlowGlobalArbitrationCount);
+
   if (allowSpill) {
-    reclaimUsedMemoryFromCandidatesBySpill(&op, freedBytes);
-    if (freedBytes >= op.requestBytes) {
-      return freedBytes;
+    reclaimUsedMemoryFromCandidatesBySpill(&op, unreturnedFreedBytes);
+    totalFreedBytes += unreturnedFreedBytes;
+    if (unreturnedFreedBytes > 0) {
+      incrementFreeCapacity(unreturnedFreedBytes);
+      unreturnedFreedBytes = 0;
+    }
+    if (totalFreedBytes >= op.requestBytes) {
+      return totalFreedBytes;
     }
     if (allowAbort) {
       // Candidate stats may change after spilling.
       getCandidates(&op);
     }
   }
+
   if (allowAbort) {
-    reclaimUsedMemoryFromCandidatesByAbort(&op, freedBytes);
+    reclaimUsedMemoryFromCandidatesByAbort(&op, unreturnedFreedBytes);
+    totalFreedBytes += unreturnedFreedBytes;
+    if (unreturnedFreedBytes > 0) {
+      incrementFreeCapacity(unreturnedFreedBytes);
+      unreturnedFreedBytes = 0;
+    }
   }
-  return freedBytes;
+  return totalFreedBytes;
 }
 
 void SharedArbitrator::testingFreeCapacity(uint64_t capacity) {
diff --git a/velox/common/memory/tests/MemoryArbitratorTest.cpp b/velox/common/memory/tests/MemoryArbitratorTest.cpp
index 30ff9acda2868..848ab33f79603 100644
--- a/velox/common/memory/tests/MemoryArbitratorTest.cpp
+++ b/velox/common/memory/tests/MemoryArbitratorTest.cpp
@@ -285,30 +285,6 @@ TEST_F(MemoryArbitrationTest, reservedCapacityFreeByPoolRelease) {
   ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 6 << 20);
 }
 
-TEST_F(MemoryArbitrationTest, reservedCapacityFreeByPoolShrink) {
-  MemoryManagerOptions options;
-  options.arbitratorKind = "SHARED";
-  options.arbitratorReservedCapacity = 4 << 20;
-  options.arbitratorCapacity = 8 << 20;
-  options.allocatorCapacity = options.arbitratorCapacity;
-  options.memoryPoolInitCapacity = 2 << 20;
-  options.memoryPoolReservedCapacity = 1 << 20;
-
-  MemoryManager manager(options);
-  auto* arbitrator = manager.arbitrator();
-  const int numPools = 6;
-  std::vector<std::shared_ptr<MemoryPool>> pools;
-  for (int i = 0; i < numPools; ++i) {
-    pools.push_back(manager.addRootPool("", kMaxMemory));
-    ASSERT_GE(pools.back()->capacity(), 1 << 20);
-  }
-  ASSERT_EQ(arbitrator->stats().freeCapacityBytes, 0);
-  pools.push_back(manager.addRootPool("", kMaxMemory));
-
-  ASSERT_GE(pools.back()->capacity(), 0);
-  ASSERT_EQ(arbitrator->shrinkCapacity(1 << 20), 2 << 20);
-}
-
 TEST_F(MemoryArbitrationTest, arbitratorStats) {
   const MemoryArbitrator::Stats emptyStats;
   ASSERT_TRUE(emptyStats.empty());
diff --git a/velox/common/memory/tests/MockSharedArbitratorTest.cpp b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
index 9f0356f8ca100..3b701391fab9c 100644
--- a/velox/common/memory/tests/MockSharedArbitratorTest.cpp
+++ b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
@@ -795,10 +795,12 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
       for (const auto& testTask : testTasks) {
         tasksOss << "[";
         tasksOss << testTask.debugString();
-        tasksOss << "], ";
+        tasksOss << "], \n";
       }
       return fmt::format(
-          "testTasks: [{}], targetBytes: {}, expectedFreedBytes: {}, expectedFreeCapacity: {}, expectedReservedFreeCapacity: {}, allowSpill: {}, allowAbort: {}",
+          "testTasks: \n[{}], \ntargetBytes: {}, \nexpectedFreedBytes: {}, "
+          "\nexpectedFreeCapacity: {}, \nexpectedReservedFreeCapacity: {}, \n"
+          "allowSpill: {}, \nallowAbort: {}",
           tasksOss.str(),
           succinctBytes(targetBytes),
           succinctBytes(expectedFreedBytes),
@@ -808,28 +810,6 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
           allowAbort);
     }
   } testSettings[] = {
-      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolReserveCapacity, false}},
-       0,
-       18 << 20,
-       24 << 20,
-       reservedMemoryCapacity,
-       true,
-       false},
-
-      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
-       0,
-       18 << 20,
-       24 << 20,
-       reservedMemoryCapacity,
-       true,
-       false},
-
       {{{memoryPoolInitCapacity,
          false,
          memoryPoolInitCapacity,
@@ -843,9 +823,9 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
          memoryPoolReserveCapacity,
          false}},
        0,
-       12 << 20,
-       18 << 20,
-       reservedMemoryCapacity,
+       0,
+       6 << 20,
+       6 << 20,
        true,
        false},
 
@@ -862,8 +842,8 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
          memoryPoolReserveCapacity,
          false}},
        0,
-       20 << 20,
-       26 << 20,
+       8 << 20,
+       14 << 20,
        reservedMemoryCapacity,
        true,
        false},
@@ -881,9 +861,9 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
          memoryPoolReserveCapacity,
          false}},
        0,
-       12 << 20,
-       18 << 20,
-       reservedMemoryCapacity,
+       0,
+       6 << 20,
+       6 << 20,
        false,
        false},
 
@@ -900,9 +880,9 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
          memoryPoolReserveCapacity,
          false}},
        0,
-       12 << 20,
-       18 << 20,
-       reservedMemoryCapacity,
+       0,
+       6 << 20,
+       6 << 20,
        true,
        false},
 
@@ -941,26 +921,15 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
         {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
         {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
        16 << 20,
-       16 << 20,
-       22 << 20,
-       reservedMemoryCapacity,
+       0,
+       6 << 20,
+       6 << 20,
        false,
        false},
 
       {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
-       16 << 20,
-       16 << 20,
-       22 << 20,
-       reservedMemoryCapacity,
-       true,
-       false},
-
-      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
         {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
        16 << 20,
        16 << 20,
@@ -970,34 +939,12 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
        true},
 
       {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
-       14 << 20,
-       14 << 20,
-       20 << 20,
-       reservedMemoryCapacity,
-       false,
-       false},
-
-      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
-       12 << 20,
-       12 << 20,
-       18 << 20,
-       reservedMemoryCapacity,
-       true,
-       false},
-
-      {{{memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, true, 0, memoryPoolInitCapacity, false},
-        {memoryPoolInitCapacity, false, 0, memoryPoolInitCapacity, false},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
+        {memoryPoolInitCapacity, false, 1 << 10, memoryPoolInitCapacity, true},
         {memoryPoolInitCapacity, true, 0, memoryPoolReserveCapacity, false}},
        14 << 20,
-       14 << 20,
-       20 << 20,
+       16 << 20,
+       22 << 20,
        reservedMemoryCapacity,
        true,
        true},
@@ -1029,33 +976,6 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
        true,
        false},
 
-      {{{memoryPoolInitCapacity,
-         true,
-         memoryPoolInitCapacity,
-         memoryPoolInitCapacity,
-         false},
-        {memoryPoolInitCapacity,
-         true,
-         memoryPoolInitCapacity,
-         memoryPoolInitCapacity,
-         false},
-        {memoryPoolInitCapacity,
-         false,
-         memoryPoolInitCapacity,
-         memoryPoolInitCapacity,
-         false},
-        {memoryPoolInitCapacity,
-         true,
-         memoryPoolReserveCapacity,
-         memoryPoolReserveCapacity,
-         false}},
-       14 << 20,
-       0,
-       6 << 20,
-       6 << 20,
-       false,
-       false},
-
       {{{memoryPoolInitCapacity,
          true,
          memoryPoolInitCapacity,
@@ -1083,33 +1003,6 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
        false,
        true},
 
-      {{{memoryPoolInitCapacity,
-         false,
-         memoryPoolInitCapacity,
-         memoryPoolInitCapacity,
-         false},
-        {memoryPoolInitCapacity,
-         false,
-         memoryPoolInitCapacity,
-         memoryPoolInitCapacity,
-         false},
-        {memoryPoolInitCapacity,
-         false,
-         memoryPoolInitCapacity,
-         memoryPoolInitCapacity,
-         false},
-        {memoryPoolInitCapacity,
-         false,
-         memoryPoolReserveCapacity,
-         memoryPoolReserveCapacity,
-         false}},
-       14 << 20,
-       0,
-       6 << 20,
-       6 << 20,
-       false,
-       false},
-
       {{{memoryPoolInitCapacity,
          false,
          memoryPoolInitCapacity,

From 3325e9666c8de70c3a94846b0ce2ac7a2250b9a1 Mon Sep 17 00:00:00 2001
From: Jimmy Lu <jimmylu@meta.com>
Date: Thu, 22 Aug 2024 06:53:09 -0700
Subject: [PATCH 09/24] Fix null compacting for ARRAY and MAP selective column
 reader (#10805)

Summary:
Pull Request resolved: https://github.com/facebookincubator/velox/pull/10805

For array/map column readers, we were using `resultNulls_` as nulls.
This is working correctly in most of the cases, except when during `read` call,
we decide to reuse reader nulls, but later there is another filter shrink the
row set, and cause that we need to compact the reader nulls into result nulls.
Although we set the bits in `resultNulls_` correctly, the `returnReaderNulls_` is
not reset in this case and we still use the reader nulls in result vector.

Fix this by reusing the same implementation in struct column reader on all
complex type column readers.  Also clean up the unused `compactComplexValues`
method.

Reviewed By: HuamengJiang

Differential Revision: D61620252

fbshipit-source-id: b5d35c7f94a622a8f9365e2fff7e89e441d113b0
---
 velox/dwio/common/SelectiveColumnReader.cpp   | 25 +++++++++
 velox/dwio/common/SelectiveColumnReader.h     | 13 ++---
 .../common/SelectiveColumnReaderInternal.h    | 52 -------------------
 .../common/SelectiveRepeatedColumnReader.cpp  |  7 +--
 .../common/SelectiveStructColumnReader.cpp    | 10 +---
 .../dwio/common/SelectiveStructColumnReader.h |  3 +-
 velox/exec/tests/TableScanTest.cpp            | 25 +++++++++
 7 files changed, 59 insertions(+), 76 deletions(-)

diff --git a/velox/dwio/common/SelectiveColumnReader.cpp b/velox/dwio/common/SelectiveColumnReader.cpp
index e8cebff97ebf5..278f09291355b 100644
--- a/velox/dwio/common/SelectiveColumnReader.cpp
+++ b/velox/dwio/common/SelectiveColumnReader.cpp
@@ -151,6 +151,31 @@ const uint64_t* SelectiveColumnReader::shouldMoveNulls(RowSet rows) {
   return moveFrom;
 }
 
+void SelectiveColumnReader::setComplexNulls(RowSet rows, VectorPtr& result)
+    const {
+  if (!nullsInReadRange_) {
+    result->clearNulls(0, rows.size());
+    return;
+  }
+  const bool dense = 1 + rows.back() == rows.size();
+  auto& nulls = result->nulls();
+  if (dense &&
+      !(nulls && nulls->isMutable() &&
+        nulls->capacity() >= bits::nbytes(rows.size()))) {
+    result->setNulls(nullsInReadRange_);
+    return;
+  }
+  auto* readerNulls = nullsInReadRange_->as<uint64_t>();
+  auto* resultNulls = result->mutableNulls(rows.size())->asMutable<uint64_t>();
+  if (dense) {
+    bits::copyBits(readerNulls, 0, resultNulls, 0, rows.size());
+    return;
+  }
+  for (vector_size_t i = 0; i < rows.size(); ++i) {
+    bits::setBit(resultNulls, i, bits::isBitSet(readerNulls, rows[i]));
+  }
+}
+
 void SelectiveColumnReader::getIntValues(
     RowSet rows,
     const TypePtr& requestedType,
diff --git a/velox/dwio/common/SelectiveColumnReader.h b/velox/dwio/common/SelectiveColumnReader.h
index b5c96a278c177..e1190f19f1f38 100644
--- a/velox/dwio/common/SelectiveColumnReader.h
+++ b/velox/dwio/common/SelectiveColumnReader.h
@@ -548,17 +548,14 @@ class SelectiveColumnReader {
   template <typename T, typename TVector>
   void compactScalarValues(RowSet rows, bool isFinal);
 
-  // Compacts values extracted for a complex type column with
-  // filter. The values for 'rows' are shifted to be consecutive at
-  // indices [0..rows.size() - 1]'. 'move' is a function that takes
-  // two indices source and target and moves the value at source to
-  // target. target is <= source for all calls.
-  template <typename Move>
-  void compactComplexValues(RowSet rows, Move move, bool isFinal);
-
   template <typename T, typename TVector>
   void upcastScalarValues(RowSet rows);
 
+  // For complex type column, we need to compact only nulls if the rows are
+  // shrinked.  Child fields are handled recursively in their own column
+  // readers.
+  void setComplexNulls(RowSet rows, VectorPtr& result) const;
+
   // Return the source null bits if compactScalarValues and upcastScalarValues
   // should move null flags.  Return nullptr if nulls does not need to be moved.
   // Checks consistency of nulls-related state.
diff --git a/velox/dwio/common/SelectiveColumnReaderInternal.h b/velox/dwio/common/SelectiveColumnReaderInternal.h
index 01819fa41c31f..a5656053cfd10 100644
--- a/velox/dwio/common/SelectiveColumnReaderInternal.h
+++ b/velox/dwio/common/SelectiveColumnReaderInternal.h
@@ -306,58 +306,6 @@ inline int32_t sizeOfIntKind(TypeKind kind) {
   }
 }
 
-template <typename Move>
-void SelectiveColumnReader::compactComplexValues(
-    RowSet rows,
-    Move move,
-    bool isFinal) {
-  VELOX_CHECK_LE(rows.size(), outputRows_.size());
-  VELOX_CHECK(!rows.empty());
-  if (rows.size() == outputRows_.size()) {
-    return;
-  }
-  RowSet sourceRows;
-  // The row numbers corresponding to elements in 'values_' are in
-  // 'valueRows_' if values have been accessed before. Otherwise
-  // they are in 'outputRows_' if these are non-empty (there is a
-  // filter) and in 'inputRows_' otherwise.
-  if (!valueRows_.empty()) {
-    sourceRows = valueRows_;
-  } else if (!outputRows_.empty()) {
-    sourceRows = outputRows_;
-  } else {
-    sourceRows = inputRows_;
-  }
-  if (valueRows_.empty()) {
-    valueRows_.resize(rows.size());
-  }
-  vector_size_t rowIndex = 0;
-  auto nextRow = rows[rowIndex];
-  auto* moveNullsFrom = shouldMoveNulls(rows);
-  for (size_t i = 0; i < numValues_; i++) {
-    if (sourceRows[i] < nextRow) {
-      continue;
-    }
-
-    VELOX_DCHECK(sourceRows[i] == nextRow);
-    // The value at i is moved to be the value at 'rowIndex'.
-    move(i, rowIndex);
-    if (moveNullsFrom && rowIndex != i) {
-      bits::setBit(rawResultNulls_, rowIndex, bits::isBitSet(moveNullsFrom, i));
-    }
-    if (!isFinal) {
-      valueRows_[rowIndex] = nextRow;
-    }
-    rowIndex++;
-    if (rowIndex >= rows.size()) {
-      break;
-    }
-    nextRow = rows[rowIndex];
-  }
-  numValues_ = rows.size();
-  valueRows_.resize(numValues_);
-}
-
 template <typename T>
 void SelectiveColumnReader::filterNulls(
     RowSet rows,
diff --git a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
index eae6e50758d51..4b7713433d6d5 100644
--- a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
+++ b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
@@ -153,9 +153,6 @@ void SelectiveRepeatedColumnReader::makeOffsetsAndSizes(
     rawOffsets[i] = nestedRowIndex;
     if (nulls && bits::isBitNull(nulls, row)) {
       rawSizes[i] = 0;
-      if (!returnReaderNulls_) {
-        bits::setNull(rawResultNulls_, i);
-      }
       anyNulls_ = true;
     } else {
       currentOffset += allLengths_[row];
@@ -240,7 +237,7 @@ void SelectiveListColumnReader::getValues(RowSet rows, VectorPtr* result) {
   prepareResult(*result, requestedType_, rows.size(), &memoryPool_);
   auto* resultArray = result->get()->asUnchecked<ArrayVector>();
   makeOffsetsAndSizes(rows, *resultArray);
-  result->get()->setNulls(resultNulls());
+  setComplexNulls(rows, *result);
   if (child_ && !nestedRows_.empty()) {
     auto& elements = resultArray->elements();
     prepareStructResult(requestedType_->childAt(0), &elements);
@@ -321,7 +318,7 @@ void SelectiveMapColumnReader::getValues(RowSet rows, VectorPtr* result) {
   prepareResult(*result, requestedType_, rows.size(), &memoryPool_);
   auto* resultMap = result->get()->asUnchecked<MapVector>();
   makeOffsetsAndSizes(rows, *resultMap);
-  result->get()->setNulls(resultNulls());
+  setComplexNulls(rows, *result);
   VELOX_CHECK(
       keyReader_ && elementReader_,
       "keyReader_ and elementReaer_ must exist in "
diff --git a/velox/dwio/common/SelectiveStructColumnReader.cpp b/velox/dwio/common/SelectiveStructColumnReader.cpp
index e0509810fc871..7df3242bae989 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.cpp
+++ b/velox/dwio/common/SelectiveStructColumnReader.cpp
@@ -386,15 +386,7 @@ void SelectiveStructColumnReaderBase::getValues(
   if (!rows.size()) {
     return;
   }
-  if (nullsInReadRange_) {
-    auto readerNulls = nullsInReadRange_->as<uint64_t>();
-    auto* nulls = resultRow->mutableNulls(rows.size())->asMutable<uint64_t>();
-    for (size_t i = 0; i < rows.size(); ++i) {
-      bits::setBit(nulls, i, bits::isBitSet(readerNulls, rows[i]));
-    }
-  } else {
-    resultRow->clearNulls(0, rows.size());
-  }
+  setComplexNulls(rows, *result);
   bool lazyPrepared = false;
   for (auto& childSpec : scanSpec_->children()) {
     VELOX_TRACE_HISTORY_PUSH("getValues %s", childSpec->fieldName().c_str());
diff --git a/velox/dwio/common/SelectiveStructColumnReader.h b/velox/dwio/common/SelectiveStructColumnReader.h
index b74f89929eed3..be7efd1045f3a 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.h
+++ b/velox/dwio/common/SelectiveStructColumnReader.h
@@ -390,7 +390,6 @@ SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::calculateOffsets(
   for (vector_size_t i = 0; i < rows.size(); ++i) {
     if (!reader_.returnReaderNulls_ && nulls &&
         bits::isBitNull(nulls, rows[i])) {
-      bits::setNull(reader_.rawResultNulls_, i);
       reader_.anyNulls_ = true;
     }
     offsets[i] = numNestedRows;
@@ -546,7 +545,7 @@ void SelectiveFlatMapColumnReaderHelper<T, KeyNode, FormatData>::getValues(
   std::copy_backward(
       rawOffsets, rawOffsets + rows.size() - 1, rawOffsets + rows.size());
   rawOffsets[0] = 0;
-  result->get()->setNulls(reader_.resultNulls());
+  reader_.setComplexNulls(rows, *result);
 }
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/exec/tests/TableScanTest.cpp b/velox/exec/tests/TableScanTest.cpp
index 51228943bfdb6..145ede14480d8 100644
--- a/velox/exec/tests/TableScanTest.cpp
+++ b/velox/exec/tests/TableScanTest.cpp
@@ -3153,6 +3153,31 @@ TEST_F(TableScanTest, mapIsNullFilter) {
       "SELECT * FROM tmp WHERE c0 is null");
 }
 
+TEST_F(TableScanTest, compactComplexNulls) {
+  constexpr int kSize = 10;
+  auto iota = makeFlatVector<int64_t>(kSize, folly::identity);
+  std::vector<vector_size_t> offsets(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    offsets[i] = (i + 1) / 2 * 2;
+  }
+  auto c0 = makeRowVector(
+      {
+          makeArrayVector(offsets, iota, {1, 3, 5, 7, 9}),
+          iota,
+      },
+      [](auto i) { return i == 2; });
+  auto data = makeRowVector({c0});
+  auto schema = asRowType(data->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {data});
+  auto plan = PlanBuilder().tableScan(schema, {"(c0).c1 > 0"}).planNode();
+  auto split = makeHiveConnectorSplit(file->getPath());
+  const vector_size_t indices[] = {1, 3, 4, 5, 6, 7, 8, 9};
+  auto expected = makeRowVector({wrapInDictionary(
+      makeIndices(8, [&](auto i) { return indices[i]; }), c0)});
+  AssertQueryBuilder(plan).split(split).assertResults(expected);
+}
+
 TEST_F(TableScanTest, remainingFilter) {
   auto rowType = ROW(
       {"c0", "c1", "c2", "c3"}, {INTEGER(), INTEGER(), DOUBLE(), BOOLEAN()});

From d0fc5e3397ea5211c042a1390ae1130c86d289f2 Mon Sep 17 00:00:00 2001
From: Krishna Pai <kpai@fb.com>
Date: Thu, 22 Aug 2024 08:05:10 -0700
Subject: [PATCH 10/24] Ensure we throw on casting unicode to integral types
 (#10804)

Summary:
Velox currently uses folly for casting varchar to integral type whereas Presto supports a lot more (see : https://github.com/facebookincubator/velox/issues/10803) . Folly only supports ascii characters at the moment and thus if we get unicode chars this can cause potential correctness issues if wrapped in a try cast.  This PR thus throws a system error if we encounter a unicode char during conversion to ensure we dont return incorrect results till unicode support for casting is added.

This change only affects PrestoCastPolicy and thus Presto.

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10804

Reviewed By: kagamiori

Differential Revision: D61627251

Pulled By: kgpai

fbshipit-source-id: dd026ccb1f5e6fe5459ef3777f87e19ab6c5cb21
---
 velox/expression/CastExpr-inl.h               | 12 +++++++++++
 velox/expression/tests/CastExprTest.cpp       |  6 ++++++
 .../functions/prestosql/tests/CastBaseTest.h  | 21 +++++++++++++------
 velox/type/Conversions.h                      |  6 ++++++
 4 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/velox/expression/CastExpr-inl.h b/velox/expression/CastExpr-inl.h
index e7ddbd5ae56a4..d22b4adac8704 100644
--- a/velox/expression/CastExpr-inl.h
+++ b/velox/expression/CastExpr-inl.h
@@ -303,6 +303,18 @@ void CastExpr::applyCastKernel(
         setResultOrError(castResult, row);
         return;
       }
+
+      if constexpr (
+          ToKind == TypeKind::TINYINT || ToKind == TypeKind::SMALLINT ||
+          ToKind == TypeKind::INTEGER || ToKind == TypeKind::BIGINT ||
+          ToKind == TypeKind::HUGEINT) {
+        if constexpr (TPolicy::throwOnUnicode) {
+          VELOX_CHECK(
+              functions::stringCore::isAscii(
+                  inputRowValue.data(), inputRowValue.size()),
+              "Unicode characters are not supported for conversion to integer types");
+        }
+      }
     }
 
     const auto castResult =
diff --git a/velox/expression/tests/CastExprTest.cpp b/velox/expression/tests/CastExprTest.cpp
index efa036d32455d..f7bea8890f0a2 100644
--- a/velox/expression/tests/CastExprTest.cpp
+++ b/velox/expression/tests/CastExprTest.cpp
@@ -1022,6 +1022,12 @@ TEST_F(CastExprTest, primitiveInvalidCornerCases) {
         "bigint", {"infinity"}, "Invalid leading character");
     testInvalidCast<std::string>(
         "bigint", {"nan"}, "Invalid leading character");
+    testInvalidCast<std::string>(
+        "bigint",
+        {"٣"},
+        "Unicode characters are not supported for conversion to integer types",
+        VARCHAR(),
+        true);
   }
 
   // To floating-point.
diff --git a/velox/functions/prestosql/tests/CastBaseTest.h b/velox/functions/prestosql/tests/CastBaseTest.h
index 6f1d6b102229c..7359f50ad7474 100644
--- a/velox/functions/prestosql/tests/CastBaseTest.h
+++ b/velox/functions/prestosql/tests/CastBaseTest.h
@@ -186,12 +186,21 @@ class CastBaseTest : public FunctionBaseTest {
       const std::string& typeString,
       const std::vector<std::optional<TFrom>>& input,
       const std::string& expectedErrorMessage,
-      const TypePtr& fromType = CppToType<TFrom>::create()) {
-    VELOX_ASSERT_THROW(
-        evaluate(
-            fmt::format("cast(c0 as {})", typeString),
-            makeRowVector({makeNullableFlatVector(input, fromType)})),
-        expectedErrorMessage);
+      const TypePtr& fromType = CppToType<TFrom>::create(),
+      const bool isRunTimeThrow = false) {
+    if (!isRunTimeThrow) {
+      VELOX_ASSERT_USER_THROW(
+          evaluate(
+              fmt::format("cast(c0 as {})", typeString),
+              makeRowVector({makeNullableFlatVector(input, fromType)})),
+          expectedErrorMessage);
+    } else {
+      VELOX_ASSERT_RUNTIME_THROW(
+          evaluate(
+              fmt::format("cast(c0 as {})", typeString),
+              makeRowVector({makeNullableFlatVector(input, fromType)})),
+          expectedErrorMessage);
+    }
   }
 
   void testCast(
diff --git a/velox/type/Conversions.h b/velox/type/Conversions.h
index e0ac382a16c1f..171bd553c3de1 100644
--- a/velox/type/Conversions.h
+++ b/velox/type/Conversions.h
@@ -34,16 +34,22 @@ namespace facebook::velox::util {
 struct PrestoCastPolicy {
   static constexpr bool truncate = false;
   static constexpr bool legacyCast = false;
+  // Throws if we encounter unicode when converting to int
+  // See issue : https://github.com/facebookincubator/velox/issues/10803
+  // Remove when unicode support is added.
+  static constexpr bool throwOnUnicode = true;
 };
 
 struct SparkCastPolicy {
   static constexpr bool truncate = true;
   static constexpr bool legacyCast = false;
+  static constexpr bool throwOnUnicode = false;
 };
 
 struct LegacyCastPolicy {
   static constexpr bool truncate = false;
   static constexpr bool legacyCast = true;
+  static constexpr bool throwOnUnicode = false;
 };
 
 template <TypeKind KIND, typename = void, typename TPolicy = PrestoCastPolicy>

From b228e09210689bca37533f1677c606b5edc8c7e3 Mon Sep 17 00:00:00 2001
From: Deepak Majeti <deepak.majeti@ibm.com>
Date: Thu, 22 Aug 2024 16:25:26 -0700
Subject: [PATCH 11/24] Set ARROW_DEPENDENCY_SOURCE=AUTO for arrow build
 (#10819)

Summary:
The build fails with conda. See https://github.com/facebookincubator/velox/issues/10818
Resolves https://github.com/facebookincubator/velox/issues/10818

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10819

Reviewed By: kgpai

Differential Revision: D61685854

Pulled By: xiaoxmeng

fbshipit-source-id: 3891d5997d058e31f46d7f5e8eb74d7e9bb8c1ba
---
 CMake/resolve_dependency_modules/arrow/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMake/resolve_dependency_modules/arrow/CMakeLists.txt b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
index 56b673e87a391..ddf1fac71b86c 100644
--- a/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
@@ -24,6 +24,7 @@ if(VELOX_ENABLE_ARROW)
   set(ARROW_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep")
   set(ARROW_CMAKE_ARGS
       -DARROW_PARQUET=OFF
+      -DARROW_DEPENDENCY_SOURCE=AUTO
       -DARROW_WITH_THRIFT=ON
       -DARROW_WITH_LZ4=ON
       -DARROW_WITH_SNAPPY=ON

From b81dcaa9b1f8dc75e857d1e0215a0a5a56035c39 Mon Sep 17 00:00:00 2001
From: yingsu00 <yingsu00@outlook.com>
Date: Thu, 22 Aug 2024 23:14:45 -0700
Subject: [PATCH 12/24] Allow column names to contain space (#10784)

Summary:
For Hive tables with higher version than 0.13 allows the table and column names to contain spaces. This change allows spaces to be part of unquoted subscript characters

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10784

Reviewed By: Yuhta

Differential Revision: D61671346

Pulled By: kgpai

fbshipit-source-id: 2836fdee33420665faef4355397a76c4e50d786b
---
 velox/type/Tokenizer.cpp          | 2 +-
 velox/type/tests/SubfieldTest.cpp | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/velox/type/Tokenizer.cpp b/velox/type/Tokenizer.cpp
index f740596cede7e..24505ab32a768 100644
--- a/velox/type/Tokenizer.cpp
+++ b/velox/type/Tokenizer.cpp
@@ -157,7 +157,7 @@ bool Tokenizer::isUnquotedPathCharacter(char c) {
 }
 
 bool Tokenizer::isUnquotedSubscriptCharacter(char c) {
-  return c == '-' || c == '_' || isalnum(c);
+  return c == '-' || c == '_' || c == ' ' || isalnum(c);
 }
 
 std::unique_ptr<Subfield::PathElement> Tokenizer::matchQuotedSubscript() {
diff --git a/velox/type/tests/SubfieldTest.cpp b/velox/type/tests/SubfieldTest.cpp
index ea2393d2e17d1..7edeab16aeb80 100644
--- a/velox/type/tests/SubfieldTest.cpp
+++ b/velox/type/tests/SubfieldTest.cpp
@@ -57,6 +57,9 @@ void testColumnName(
 }
 
 TEST(SubfieldTest, columnNamesWithSpecialCharacters) {
+  testColumnName("two words");
+  testColumnName("two  words");
+  testColumnName("one two three");
   testColumnName("$bucket");
   testColumnName("apollo-11");
   testColumnName("a/b/c:12");

From 2111fb59adf5e1afef3578d953c423f794dee503 Mon Sep 17 00:00:00 2001
From: Jialiang Tan <jacob.jialiang.tan@gmail.com>
Date: Thu, 22 Aug 2024 23:17:40 -0700
Subject: [PATCH 13/24] Add disable pool management option to memory manager
 (#10817)

Summary:
Add this disable pool management option to give users an option to have better memory pool performance (creation), especially for high QPS use cases.

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10817

Reviewed By: xiaoxmeng

Differential Revision: D61679884

Pulled By: tanjialiang

fbshipit-source-id: dadec0a66ed0b78da56560b68b049487324bef76
---
 velox/common/memory/Memory.cpp                | 45 ++++++++++------
 velox/common/memory/Memory.h                  | 14 +++--
 velox/common/memory/MemoryArbitrator.h        |  2 +-
 .../common/memory/tests/MemoryManagerTest.cpp | 53 +++++++++++++++++++
 4 files changed, 95 insertions(+), 19 deletions(-)

diff --git a/velox/common/memory/Memory.cpp b/velox/common/memory/Memory.cpp
index fed1d3c2b6dc8..15213843b7a2a 100644
--- a/velox/common/memory/Memory.cpp
+++ b/velox/common/memory/Memory.cpp
@@ -133,12 +133,12 @@ std::vector<std::shared_ptr<MemoryPool>> createSharedLeafMemoryPools(
 
 MemoryManager::MemoryManager(const MemoryManagerOptions& options)
     : allocator_{createAllocator(options)},
-      poolInitCapacity_(options.memoryPoolInitCapacity),
       arbitrator_(createArbitrator(options)),
       alignment_(std::max(MemoryAllocator::kMinAlignment, options.alignment)),
       checkUsageLeak_(options.checkUsageLeak),
       debugEnabled_(options.debugEnabled),
       coreOnAllocationFailureEnabled_(options.coreOnAllocationFailureEnabled),
+      disableMemoryPoolTracking_(options.disableMemoryPoolTracking),
       poolDestructionCb_([&](MemoryPool* pool) { dropPool(pool); }),
       sysRoot_{std::make_shared<MemoryPoolImpl>(
           this,
@@ -246,6 +246,25 @@ uint16_t MemoryManager::alignment() const {
   return alignment_;
 }
 
+std::shared_ptr<MemoryPool> MemoryManager::createRootPool(
+    std::string poolName,
+    std::unique_ptr<MemoryReclaimer>& reclaimer,
+    MemoryPool::Options& options) {
+  auto pool = std::make_shared<MemoryPoolImpl>(
+      this,
+      poolName,
+      MemoryPool::Kind::kAggregate,
+      nullptr,
+      std::move(reclaimer),
+      poolDestructionCb_,
+      options);
+  VELOX_CHECK_EQ(pool->capacity(), 0);
+  arbitrator_->addPool(pool);
+  RECORD_HISTOGRAM_METRIC_VALUE(
+      kMetricMemoryPoolInitialCapacityBytes, pool->capacity());
+  return pool;
+}
+
 std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
     const std::string& name,
     int64_t maxCapacity,
@@ -263,23 +282,16 @@ std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
   options.debugEnabled = debugEnabled_;
   options.coreOnAllocationFailureEnabled = coreOnAllocationFailureEnabled_;
 
+  if (disableMemoryPoolTracking_) {
+    return createRootPool(poolName, reclaimer, options);
+  }
+
   std::unique_lock guard{mutex_};
   if (pools_.find(poolName) != pools_.end()) {
     VELOX_FAIL("Duplicate root pool name found: {}", poolName);
   }
-  auto pool = std::make_shared<MemoryPoolImpl>(
-      this,
-      poolName,
-      MemoryPool::Kind::kAggregate,
-      nullptr,
-      std::move(reclaimer),
-      poolDestructionCb_,
-      options);
+  auto pool = createRootPool(poolName, reclaimer, options);
   pools_.emplace(poolName, pool);
-  VELOX_CHECK_EQ(pool->capacity(), 0);
-  arbitrator_->addPool(pool);
-  RECORD_HISTOGRAM_METRIC_VALUE(
-      kMetricMemoryPoolInitialCapacityBytes, pool->capacity());
   return pool;
 }
 
@@ -302,6 +314,11 @@ uint64_t MemoryManager::shrinkPools(
 }
 
 void MemoryManager::dropPool(MemoryPool* pool) {
+  VELOX_DCHECK_EQ(pool->reservedBytes(), 0);
+  arbitrator_->removePool(pool);
+  if (disableMemoryPoolTracking_) {
+    return;
+  }
   VELOX_CHECK_NOT_NULL(pool);
   std::unique_lock guard{mutex_};
   auto it = pools_.find(pool->name());
@@ -309,8 +326,6 @@ void MemoryManager::dropPool(MemoryPool* pool) {
     VELOX_FAIL("The dropped memory pool {} not found", pool->name());
   }
   pools_.erase(it);
-  VELOX_DCHECK_EQ(pool->reservedBytes(), 0);
-  arbitrator_->removePool(pool);
 }
 
 MemoryPool& MemoryManager::deprecatedSharedLeafPool() {
diff --git a/velox/common/memory/Memory.h b/velox/common/memory/Memory.h
index 5ce372e77dc48..ac1085f473bfd 100644
--- a/velox/common/memory/Memory.h
+++ b/velox/common/memory/Memory.h
@@ -81,6 +81,9 @@ struct MemoryManagerOptions {
   /// Terminates the process and generates a core file on an allocation failure
   bool coreOnAllocationFailureEnabled{false};
 
+  /// Disables the memory manager's tracking on memory pools.
+  bool disableMemoryPoolTracking{false};
+
   /// ================== 'MemoryAllocator' settings ==================
 
   /// Specifies the max memory allocation capacity in bytes enforced by
@@ -344,21 +347,26 @@ class MemoryManager {
   }
 
  private:
+  std::shared_ptr<MemoryPool> createRootPool(
+      std::string poolName,
+      std::unique_ptr<MemoryReclaimer>& reclaimer,
+      MemoryPool::Options& options);
+
   void dropPool(MemoryPool* pool);
 
   //  Returns the shared references to all the alive memory pools in 'pools_'.
   std::vector<std::shared_ptr<MemoryPool>> getAlivePools() const;
 
   const std::shared_ptr<MemoryAllocator> allocator_;
-  // Specifies the capacity to allocate from 'arbitrator_' for a newly created
-  // root memory pool.
-  const uint64_t poolInitCapacity_;
+
   // If not null, used to arbitrate the memory capacity among 'pools_'.
   const std::unique_ptr<MemoryArbitrator> arbitrator_;
   const uint16_t alignment_;
   const bool checkUsageLeak_;
   const bool debugEnabled_;
   const bool coreOnAllocationFailureEnabled_;
+  const bool disableMemoryPoolTracking_;
+
   // The destruction callback set for the allocated root memory pools which are
   // tracked by 'pools_'. It is invoked on the root pool destruction and removes
   // the pool from 'pools_'.
diff --git a/velox/common/memory/MemoryArbitrator.h b/velox/common/memory/MemoryArbitrator.h
index 20b50e6012886..e5b9dc35dc580 100644
--- a/velox/common/memory/MemoryArbitrator.h
+++ b/velox/common/memory/MemoryArbitrator.h
@@ -64,7 +64,7 @@ class MemoryArbitrator {
     MemoryArbitrationStateCheckCB arbitrationStateCheckCb{nullptr};
 
     /// Additional configs that are arbitrator implementation specific.
-    std::unordered_map<std::string, std::string> extraConfigs;
+    std::unordered_map<std::string, std::string> extraConfigs{};
   };
 
   using Factory = std::function<std::unique_ptr<MemoryArbitrator>(
diff --git a/velox/common/memory/tests/MemoryManagerTest.cpp b/velox/common/memory/tests/MemoryManagerTest.cpp
index 348ed8db33775..02ac9a11fb2ab 100644
--- a/velox/common/memory/tests/MemoryManagerTest.cpp
+++ b/velox/common/memory/tests/MemoryManagerTest.cpp
@@ -620,4 +620,57 @@ TEST_F(MemoryManagerTest, quotaEnforcement) {
     }
   }
 }
+
+TEST_F(MemoryManagerTest, disableMemoryPoolTracking) {
+  const std::string kSharedKind{"SHARED"};
+  const std::string kNoopKind{""};
+  MemoryManagerOptions options;
+  options.disableMemoryPoolTracking = true;
+  options.allocatorCapacity = 64LL << 20;
+  options.arbitratorCapacity = 64LL << 20;
+  std::vector<std::string> arbitratorKinds{kNoopKind, kSharedKind};
+  for (auto arbitratorKind : arbitratorKinds) {
+    options.arbitratorKind = arbitratorKind;
+    MemoryManager manager{options};
+    auto root0 = manager.addRootPool("root_0", 35LL << 20);
+    auto leaf0 = root0->addLeafChild("leaf_0");
+
+    // Not throwing since there is no duplicate check.
+    auto root0Dup = manager.addRootPool("root_0", 35LL << 20);
+
+    // 1TB capacity is allowed since there is no capacity check.
+    auto root1 = manager.addRootPool("root_1", 1LL << 40);
+    auto leaf1 = root1->addLeafChild("leaf_1");
+
+    ASSERT_EQ(root0->capacity(), 35LL << 20);
+    if (arbitratorKind == kSharedKind) {
+      ASSERT_EQ(root0Dup->capacity(), 29LL << 20);
+      ASSERT_EQ(root1->capacity(), 0);
+    } else {
+      ASSERT_EQ(root0Dup->capacity(), 35LL << 20);
+      ASSERT_EQ(root1->capacity(), 1LL << 40);
+    }
+
+    ASSERT_EQ(manager.capacity(), 64LL << 20);
+    ASSERT_EQ(manager.shrinkPools(), 0);
+    // Default 1 system pool with 1 leaf child
+    ASSERT_EQ(manager.numPools(), 1);
+
+    VELOX_ASSERT_THROW(
+        leaf0->allocate(38LL << 20), "Exceeded memory pool capacity");
+    if (arbitratorKind == kSharedKind) {
+      VELOX_ASSERT_THROW(
+          leaf1->allocate(256LL << 20), "Exceeded memory pool capacity");
+    } else {
+      VELOX_ASSERT_THROW(
+          leaf1->allocate(256LL << 20), "Exceeded memory allocator limit");
+    }
+
+    ASSERT_NO_THROW(leaf0.reset());
+    ASSERT_NO_THROW(leaf1.reset());
+    ASSERT_NO_THROW(root0.reset());
+    ASSERT_NO_THROW(root0Dup.reset());
+    ASSERT_NO_THROW(root1.reset());
+  }
+}
 } // namespace facebook::velox::memory

From eaec1d349f19f8d5954e57e9c007117066742e1a Mon Sep 17 00:00:00 2001
From: Zuyu ZHANG <zuyu@users.noreply.github.com>
Date: Fri, 23 Aug 2024 00:25:29 -0700
Subject: [PATCH 14/24] Fix build errors in Presto due to misconfigured
 generated proto file paths (#10807)

Summary:
A follow-up fix for https://github.com/facebookincubator/velox/issues/10357

In Presto build, the following two CMake arguments for `velox` are different, although both are the same in the `velox` standalone build:
* `CMAKE_BINARY_DIR`: presto/presto-native-execution/cmake-build-debug
* `PROJECT_BINARY_DIR`: presto/presto-native-execution/cmake-build-debug/velox

```sh
Building CXX object velox/velox/functions/sparksql/fuzzer/CMakeFiles/velox_spark_query_runner.dir/__/__/__/__/spark/connect/catalog.pb.cc.o
FAILED:
clang++: error: no such file or directory: 'presto/presto-native-execution/cmake-build-debug/velox/spark/connect/catalog.pb.cc'
clang++: error: no input files

$ ls presto/presto-native-execution/cmake-build-debug/spark/connect/catalog.*
catalog.grpc.pb.cc  catalog.grpc.pb.h  catalog.pb.cc  catalog.pb.h
```

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10807

Reviewed By: xiaoxmeng

Differential Revision: D61705399

Pulled By: kgpai

fbshipit-source-id: 34828de6f513ef072c1c9a0a1aa5510a4da86739
---
 velox/functions/sparksql/fuzzer/CMakeLists.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/velox/functions/sparksql/fuzzer/CMakeLists.txt b/velox/functions/sparksql/fuzzer/CMakeLists.txt
index 917469a2e9454..75347a517eddf 100644
--- a/velox/functions/sparksql/fuzzer/CMakeLists.txt
+++ b/velox/functions/sparksql/fuzzer/CMakeLists.txt
@@ -68,7 +68,7 @@ endforeach()
 # Generate Spark connect hearders and sources.
 add_custom_command(
   OUTPUT ${PROTO_OUTPUT_FILES}
-  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${CMAKE_BINARY_DIR}
+  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${PROJECT_BINARY_DIR}
           ${PROTO_FILES_FULL}
   DEPENDS protobuf::protoc
   COMMENT "Running PROTO compiler"
@@ -78,7 +78,7 @@ add_custom_command(
 add_custom_command(
   OUTPUT ${GRPC_OUTPUT_FILES}
   COMMAND
-    protobuf::protoc ${PROTO_PATH_ARGS} --grpc_out=${CMAKE_BINARY_DIR}
+    protobuf::protoc ${PROTO_PATH_ARGS} --grpc_out=${PROJECT_BINARY_DIR}
     --plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
     ${PROTO_FILES_FULL}
   DEPENDS protobuf::protoc

From b5cd1e896bc4c5fea56042410bcf89bfe075af40 Mon Sep 17 00:00:00 2001
From: Krishna Pai <kpai@fb.com>
Date: Fri, 23 Aug 2024 08:23:13 -0700
Subject: [PATCH 15/24] Refactor RowTranslationUtil::toElementRows (#10820)

Summary:
This Pr fixes the comments on RowTranslationUtil and also ensures that it's used only for map/array vectors. We also add
some debug time safeguards for the index mappings.

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10820

Reviewed By: spershin

Differential Revision: D61693258

Pulled By: kgpai

fbshipit-source-id: 46165cf170a3b037154e8bf62b05a2e7f9f74a1a
---
 velox/functions/lib/RowsTranslationUtil.h | 38 ++++++++++++++++-------
 1 file changed, 26 insertions(+), 12 deletions(-)

diff --git a/velox/functions/lib/RowsTranslationUtil.h b/velox/functions/lib/RowsTranslationUtil.h
index bd374bb9529b2..97185203ba28c 100644
--- a/velox/functions/lib/RowsTranslationUtil.h
+++ b/velox/functions/lib/RowsTranslationUtil.h
@@ -22,26 +22,40 @@
 
 namespace facebook::velox::functions {
 
-/// Returns SelectivityVector for the nested vector with all rows corresponding
-/// to specified top-level rows selected. The optional topLevelRowMapping is
-/// used to pass the dictionary indices if the topLevelVector is dictionary
-/// encoded.
+/// This function returns a SelectivityVector for ARRAY/MAP vectors that selects
+/// all rows corresponding to the specified rows. If the base vector was
+/// dictionary encoded, an optional rowMapping parameter can be used to pass
+/// the dictionary indices. In this case, it is important to ensure that the
+/// topLevelRows parameter has already filtered out any null rows added by the
+/// dictionary encoding.
 template <typename T>
 SelectivityVector toElementRows(
     vector_size_t size,
-    const SelectivityVector& topLevelRows,
-    const T* topLevelVector,
-    const vector_size_t* topLevelRowMapping = nullptr) {
-  auto rawNulls = topLevelVector->rawNulls();
-  auto rawSizes = topLevelVector->rawSizes();
-  auto rawOffsets = topLevelVector->rawOffsets();
+    const SelectivityVector& topLevelNonNullRows,
+    const T* arrayBaseVector,
+    const vector_size_t* rowMapping = nullptr) {
+  VELOX_CHECK(
+      arrayBaseVector->encoding() == VectorEncoding::Simple::MAP ||
+      arrayBaseVector->encoding() == VectorEncoding::Simple::ARRAY);
+
+  auto rawNulls = arrayBaseVector->rawNulls();
+  auto rawSizes = arrayBaseVector->rawSizes();
+  auto rawOffsets = arrayBaseVector->rawOffsets();
+  const auto sizeRange =
+      arrayBaseVector->sizes()->template asRange<vector_size_t>().end();
+  const auto offsetRange =
+      arrayBaseVector->offsets()->template asRange<vector_size_t>().end();
 
   SelectivityVector elementRows(size, false);
-  topLevelRows.applyToSelected([&](vector_size_t row) {
-    auto index = topLevelRowMapping ? topLevelRowMapping[row] : row;
+  topLevelNonNullRows.applyToSelected([&](vector_size_t row) {
+    auto index = rowMapping ? rowMapping[row] : row;
     if (rawNulls && bits::isBitNull(rawNulls, index)) {
       return;
     }
+
+    VELOX_DCHECK_LE(index, sizeRange);
+    VELOX_DCHECK_LE(index, offsetRange);
+
     auto size = rawSizes[index];
     auto offset = rawOffsets[index];
     elementRows.setValidRange(offset, offset + size, true);

From d46459c32967d3cfdfba54840b032cd3910c43f4 Mon Sep 17 00:00:00 2001
From: Yang Zhang <yangchuan.zy@alibaba-inc.com>
Date: Fri, 23 Aug 2024 09:55:40 -0700
Subject: [PATCH 16/24] Add write IO metrics and print physical written bytes
 in PlanNodeStats#toString (#10806)

Summary:
Count write IO metrics when invoke WriteFile#append, and print physical written bytes when invoke printPlanWithStats.

Fixes: https://github.com/facebookincubator/velox/issues/10794

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10806

Reviewed By: Yuhta

Differential Revision: D61706390

Pulled By: xiaoxmeng

fbshipit-source-id: 510b8f2821c1f012a4b9714b9ac9d92ba624b2ac
---
 velox/common/io/IoStatistics.cpp            |  8 +++
 velox/common/io/IoStatistics.h              |  3 +
 velox/connectors/Connector.h                |  1 +
 velox/connectors/hive/HiveDataSink.cpp      |  3 +
 velox/dwio/common/FileSink.cpp              | 15 +++--
 velox/exec/PlanNodeStats.cpp                |  7 +-
 velox/exec/TableWriter.cpp                  |  4 ++
 velox/exec/tests/PrintPlanWithStatsTest.cpp | 73 +++++++++++++++++++++
 velox/exec/tests/TableWriteTest.cpp         |  5 ++
 9 files changed, 112 insertions(+), 7 deletions(-)

diff --git a/velox/common/io/IoStatistics.cpp b/velox/common/io/IoStatistics.cpp
index 7b7883c73dcf9..7dfddc6dc4831 100644
--- a/velox/common/io/IoStatistics.cpp
+++ b/velox/common/io/IoStatistics.cpp
@@ -46,6 +46,10 @@ uint64_t IoStatistics::totalScanTime() const {
   return totalScanTime_.load(std::memory_order_relaxed);
 }
 
+uint64_t IoStatistics::writeIOTimeUs() const {
+  return writeIOTimeUs_.load(std::memory_order_relaxed);
+}
+
 uint64_t IoStatistics::incRawBytesRead(int64_t v) {
   return rawBytesRead_.fetch_add(v, std::memory_order_relaxed);
 }
@@ -70,6 +74,10 @@ uint64_t IoStatistics::incTotalScanTime(int64_t v) {
   return totalScanTime_.fetch_add(v, std::memory_order_relaxed);
 }
 
+uint64_t IoStatistics::incWriteIOTimeUs(int64_t v) {
+  return writeIOTimeUs_.fetch_add(v, std::memory_order_relaxed);
+}
+
 void IoStatistics::incOperationCounters(
     const std::string& operation,
     const uint64_t resourceThrottleCount,
diff --git a/velox/common/io/IoStatistics.h b/velox/common/io/IoStatistics.h
index 7e5bcb0192e3e..2111a8877b475 100644
--- a/velox/common/io/IoStatistics.h
+++ b/velox/common/io/IoStatistics.h
@@ -97,6 +97,7 @@ class IoStatistics {
   uint64_t inputBatchSize() const;
   uint64_t outputBatchSize() const;
   uint64_t totalScanTime() const;
+  uint64_t writeIOTimeUs() const;
 
   uint64_t incRawBytesRead(int64_t);
   uint64_t incRawOverreadBytes(int64_t);
@@ -104,6 +105,7 @@ class IoStatistics {
   uint64_t incInputBatchSize(int64_t);
   uint64_t incOutputBatchSize(int64_t);
   uint64_t incTotalScanTime(int64_t);
+  uint64_t incWriteIOTimeUs(int64_t);
 
   IoCounter& prefetch() {
     return prefetch_;
@@ -150,6 +152,7 @@ class IoStatistics {
   std::atomic<uint64_t> outputBatchSize_{0};
   std::atomic<uint64_t> rawOverreadBytes_{0};
   std::atomic<uint64_t> totalScanTime_{0};
+  std::atomic<uint64_t> writeIOTimeUs_{0};
 
   // Planned read from storage or SSD.
   IoCounter prefetch_;
diff --git a/velox/connectors/Connector.h b/velox/connectors/Connector.h
index c16124ff66e36..1dc77823e4366 100644
--- a/velox/connectors/Connector.h
+++ b/velox/connectors/Connector.h
@@ -151,6 +151,7 @@ class DataSink {
   struct Stats {
     uint64_t numWrittenBytes{0};
     uint32_t numWrittenFiles{0};
+    uint64_t writeIOTimeUs{0};
     common::SpillStats spillStats;
 
     bool empty() const;
diff --git a/velox/connectors/hive/HiveDataSink.cpp b/velox/connectors/hive/HiveDataSink.cpp
index a185ca20e9d41..c0d5cb46b9fa5 100644
--- a/velox/connectors/hive/HiveDataSink.cpp
+++ b/velox/connectors/hive/HiveDataSink.cpp
@@ -511,10 +511,13 @@ DataSink::Stats HiveDataSink::stats() const {
   }
 
   int64_t numWrittenBytes{0};
+  int64_t writeIOTimeUs{0};
   for (const auto& ioStats : ioStats_) {
     numWrittenBytes += ioStats->rawBytesWritten();
+    writeIOTimeUs += ioStats->writeIOTimeUs();
   }
   stats.numWrittenBytes = numWrittenBytes;
+  stats.writeIOTimeUs = writeIOTimeUs;
 
   if (state_ != State::kClosed) {
     return stats;
diff --git a/velox/dwio/common/FileSink.cpp b/velox/dwio/common/FileSink.cpp
index 0f69ee1cc510d..cebfe54c3bbf2 100644
--- a/velox/dwio/common/FileSink.cpp
+++ b/velox/dwio/common/FileSink.cpp
@@ -67,14 +67,19 @@ void FileSink::writeImpl(
     const std::function<uint64_t(const DataBuffer<char>&)>& callback) {
   DWIO_ENSURE(!isClosed(), "Cannot write to closed sink.");
   const uint64_t oldSize = size_;
-  for (auto& buf : buffers) {
-    // NOTE: we need to update 'size_' after each 'callback' invocation as some
-    // file sink implementation like MemorySink depends on the updated 'size_'
-    // for new write.
-    size_ += callback(buf);
+  uint64_t writeTimeUs{0};
+  {
+    MicrosecondTimer timer(&writeTimeUs);
+    for (auto& buf : buffers) {
+      // NOTE: we need to update 'size_' after each 'callback' invocation as
+      // some file sink implementation like MemorySink depends on the updated
+      // 'size_' for new write.
+      size_ += callback(buf);
+    }
   }
   if (stats_ != nullptr) {
     stats_->incRawBytesWritten(size_ - oldSize);
+    stats_->incWriteIOTimeUs(writeTimeUs);
   }
   // Writing buffer is treated as transferring ownership. So clearing the
   // buffers after all buffers are written.
diff --git a/velox/exec/PlanNodeStats.cpp b/velox/exec/PlanNodeStats.cpp
index caab8f7648728..940d5c6d49618 100644
--- a/velox/exec/PlanNodeStats.cpp
+++ b/velox/exec/PlanNodeStats.cpp
@@ -95,8 +95,11 @@ std::string PlanNodeStats::toString(bool includeInputStats) const {
     }
   }
   out << "Output: " << outputRows << " rows (" << succinctBytes(outputBytes)
-      << ", " << outputVectors << " batches)"
-      << ", Cpu time: " << succinctNanos(cpuWallTiming.cpuNanos)
+      << ", " << outputVectors << " batches)";
+  if (physicalWrittenBytes > 0) {
+    out << ", Physical written output: " << succinctBytes(physicalWrittenBytes);
+  }
+  out << ", Cpu time: " << succinctNanos(cpuWallTiming.cpuNanos)
       << ", Blocked wall time: " << succinctNanos(blockedWallNanos)
       << ", Peak memory: " << succinctBytes(peakMemoryBytes)
       << ", Memory allocations: " << numMemoryAllocations;
diff --git a/velox/exec/TableWriter.cpp b/velox/exec/TableWriter.cpp
index b8e0fca88e498..9bd199cfe9ffc 100644
--- a/velox/exec/TableWriter.cpp
+++ b/velox/exec/TableWriter.cpp
@@ -253,6 +253,10 @@ void TableWriter::updateStats(const connector::DataSink::Stats& stats) {
     }
     lockedStats->addRuntimeStat(
         "numWrittenFiles", RuntimeCounter(stats.numWrittenFiles));
+    lockedStats->addRuntimeStat(
+        "writeIOTime",
+        RuntimeCounter(
+            stats.writeIOTimeUs * 1000, RuntimeCounter::Unit::kNanos));
   }
   if (!stats.spillStats.empty()) {
     *spillStats_.wlock() += stats.spillStats;
diff --git a/velox/exec/tests/PrintPlanWithStatsTest.cpp b/velox/exec/tests/PrintPlanWithStatsTest.cpp
index f426f66dc85c0..9b52725c3feea 100644
--- a/velox/exec/tests/PrintPlanWithStatsTest.cpp
+++ b/velox/exec/tests/PrintPlanWithStatsTest.cpp
@@ -18,6 +18,7 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 #include <gtest/gtest.h>
 #include <re2/re2.h>
@@ -309,3 +310,75 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
          {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
   }
 }
+
+TEST_F(PrintPlanWithStatsTest, tableWriterWithTableScan) {
+  RowTypePtr rowType{
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {BIGINT(), INTEGER(), SMALLINT(), REAL(), DOUBLE(), VARCHAR()})};
+  auto vectors = makeVectors(rowType, 10, 10);
+
+  const auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  const auto writeDir = TempDirectoryPath::create();
+
+  auto writePlan = PlanBuilder()
+                       .tableScan(rowType)
+                       .tableWrite(writeDir->getPath())
+                       .planNode();
+
+  std::shared_ptr<exec::Task> task;
+  AssertQueryBuilder(writePlan)
+      .splits(makeHiveConnectorSplits({filePath}))
+      .copyResults(pool(), task);
+  ensureTaskCompletion(task.get());
+  compareOutputs(
+      ::testing::UnitTest::GetInstance()->current_test_info()->name(),
+      printPlanWithStats(*writePlan, task->taskStats()),
+      {{R"(-- TableWrite\[1\]\[.+InsertTableHandle .+)"},
+       {"   Output: .+, Physical written output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
+       {R"(  -- TableScan\[0\]\[table: hive_table\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR)"},
+       {R"(     Input: 100 rows \(.+\), Output: 100 rows \(.+\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1)"}});
+
+  compareOutputs(
+      ::testing::UnitTest::GetInstance()->current_test_info()->name(),
+      printPlanWithStats(*writePlan, task->taskStats(), true),
+      {{R"(-- TableWrite\[1\]\[.+InsertTableHandle .+)"},
+       {"   Output: .+, Physical written output: .+, Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1"},
+       {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"      numWrittenFiles\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      stripeSize\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      writeIOTime\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {R"(  -- TableScan\[0\]\[table: hive_table\] -> c0:BIGINT, c1:INTEGER, c2:SMALLINT, c3:REAL, c4:DOUBLE, c5:VARCHAR)"},
+       {R"(     Input: 100 rows \(.+\), Output: 100 rows \(.+\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, Splits: 1)"},
+       {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        dataSourceReadWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        flattenStringDictionaryValues [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
+       {"        localReadBytes   [ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+       {"        maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
+       {"        numLocalRead     [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"        numRamRead       [ ]* sum: 7, count: 1, min: 7, max: 7"},
+       {"        numStorageRead   [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+
+       {"        prefetchBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"        ramReadBytes     [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        readyPreloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
+        true},
+       {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        runningFinishWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"        skippedSplitBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B"},
+       {"        skippedSplits    [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        skippedStrides   [ ]* sum: 0, count: 1, min: 0, max: 0"},
+       {"        storageReadBytes [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        totalRemainingFilterTime\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
+}
diff --git a/velox/exec/tests/TableWriteTest.cpp b/velox/exec/tests/TableWriteTest.cpp
index f249fc612c277..c54ebd3e443be 100644
--- a/velox/exec/tests/TableWriteTest.cpp
+++ b/velox/exec/tests/TableWriteTest.cpp
@@ -2360,6 +2360,8 @@ TEST_P(UnpartitionedTableWriterTest, runtimeStatsCheck) {
         stats[1].runtimeStats["stripeSize"].count, testData.expectedNumStripes);
     ASSERT_EQ(stats[1].runtimeStats["numWrittenFiles"].sum, 1);
     ASSERT_EQ(stats[1].runtimeStats["numWrittenFiles"].count, 1);
+    ASSERT_GE(stats[1].runtimeStats["writeIOTime"].sum, 0);
+    ASSERT_EQ(stats[1].runtimeStats["writeIOTime"].count, 1);
   }
 }
 
@@ -3132,6 +3134,9 @@ TEST_P(AllTableWriterTest, tableWriterStats) {
           ->customStats.at("numWrittenFiles")
           .sum,
       numWrittenFiles);
+  ASSERT_GE(
+      stats.operatorStats.at("TableWrite")->customStats.at("writeIOTime").sum,
+      0);
 }
 
 DEBUG_ONLY_TEST_P(

From 52c1daaa10a896d2e96f322b710ed5860dbd4e53 Mon Sep 17 00:00:00 2001
From: snadukudy <51390531+snadukudy@users.noreply.github.com>
Date: Fri, 23 Aug 2024 10:42:47 -0700
Subject: [PATCH 17/24] Add CI migration blog post (#10532)

Summary:
Add blog post on CircleCI migration to GitHub Actions

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10532

Reviewed By: amitkdutta

Differential Revision: D61669570

Pulled By: kgpai

fbshipit-source-id: 6c951e630f4ebc9930342809819d5046e4913024
---
 website/blog/2024-08-23-ci-migration.mdx      |  78 ++++++++++++++++++
 .../static/img/abstract-white-background.jpg  | Bin 0 -> 132559 bytes
 website/static/img/velox-build-metrics.png    | Bin 0 -> 103291 bytes
 3 files changed, 78 insertions(+)
 create mode 100644 website/blog/2024-08-23-ci-migration.mdx
 create mode 100644 website/static/img/abstract-white-background.jpg
 create mode 100644 website/static/img/velox-build-metrics.png

diff --git a/website/blog/2024-08-23-ci-migration.mdx b/website/blog/2024-08-23-ci-migration.mdx
new file mode 100644
index 0000000000000..398c17279b607
--- /dev/null
+++ b/website/blog/2024-08-23-ci-migration.mdx
@@ -0,0 +1,78 @@
+---
+slug: ci-migration
+title: "Optimizing and Migrating Velox CI Workloads to Github Actions"
+authors: [jwujciak, kgpai]
+tags: [tech-blog, packaging]
+---
+
+<figure>
+ <img src="/img/abstract-white-background.jpg" height= "100%" width="100%"/>
+</figure>
+
+## TL;DR
+
+In late 2023, the Meta OSS (Open Source Software) Team requested all Meta teams to move the CI deployments from CircleCI to Github Actions. [Voltron Data](http://voltrondata.com) and Meta in collaboration migrated all the deployed Velox CI jobs. For the year 2024, Velox CI spend was on track to overshoot the allocated resources by a considerable amount of money. As part of this migration effort, the CI workloads were consolidated and optimized by Q2 2024, bringing down the projected 2024 CI spend by 51%.
+
+## Velox’s Continuous Integration Workload
+
+Continuous Integration (CI) is crucial for Velox’s success as an open source project as it helps protect from bugs and errors, reduces likelihood of conflicts and leads to increased community trust in the project. This is to ensure the Velox builds works well on a myriad of system architectures, operating systems and compilers - along with the ones used internally at Meta. The OSS build version of Velox also supports additional features that aren't used internally in Meta (for example, support for Cloud blob stores, etc.).
+
+When a pull request is submitted to Velox, the following jobs are executed:
+
+1. Linting and Formatting workflows:
+    1. Header checks
+    2. License checks
+    3. Basic Linters 
+2. Ensure Velox builds on various platforms
+    1. MacOS (Intel, M1)
+    2. Linux (Ubuntu/Centos)
+3. Ensure Velox builds under its various configurations
+    1. Debug / Release builds
+    2. Build default Velox build
+    3. Build Velox with support for Parquet, Arrow and External Adapters (S3/HDFS/GCS etc.)
+    4. PyVelox builds
+4. Run prerequisite tests 
+    1. Unit Tests
+    2. Benchmarking Tests
+        1. [Conbench](https://velox-conbench.voltrondata.run/runs/5bd139fffa9b4e0eb020da4d63211121/) is used to store and compare results, and also alert users on regressions
+    3. Various Fuzzer Tests (Expression / Aggregation/ Exchange / Join etc) 
+    4. Signature Check and Biased Fuzzer Tests ( Expression / Aggregation)
+    5. Fuzzer Tests using Presto as source of truth
+5. Docker Image build jobs
+    1. If an underlying dependency is changed, a new Docker CI image is built for
+        1. Ubuntu Linux
+        2. Centos
+        3. Presto Linux image
+6. Documentation build and publish Job
+    1. If underlying documentation is changed, Velox documentation pages are rebuilt and published
+    2. Netlify is used for publishing Velox web pages
+
+## Velox CI Optimization
+
+Previous implementation of CI in CircleCI grew organically and was unoptimized, resulting in long build times, and also significantly costlier. This opportunity to migrate to Github Actions helped to take a holistic view of CI deployments and actively optimized to reduce build times and CI spend. Note however, that there has been continued investment in reducing test times to further improve Velox reliability, stability and developer experience. Some of the optimizations completed are:  
+
+1. **Persisting build artifacts across builds**: During every build, the object files and binaries produced are cached. In addition to this, artifacts such as scalar function signatures and aggregate function signatures are produced. These signatures are used to compare with the baseline version, by comparing against the changes in the current PR to determine if the current changes are backwards incompatible or bias the newly added changes. Using a stash to persist these artifacts helps save one build cycle.
+
+2. **Optimizing our Instances**: Building Velox is Memory and CPU intensive job. Some beefy instances (16-core machines) are used to build Velox. After the build, the build artifacts are copied to smaller instances (4 core machines) to run fuzzer tests and other jobs. Since these fuzzers often run for an hour and are less intensive than the build process, it resulted in significant CI savings while increasing the test coverage.
+
+## Instrumenting Velox CI Builds
+
+Velox CI builds were instrumented in Conbench so that it can capture various metrics about the builds: 
+1. Build times at translation unit / library/ project level.
+2. Binary sizes produced at TLU/ .a,.so / executable level.
+3. Memory pressure 
+4. Measure across time how our changes affect binary sizes 
+
+A nightly job is run to capture these build metrics and it is uploaded to Conbench. Velox build metrics report is available here: [Velox Build Metrics Report](https://facebookincubator.github.io/velox/bm-report/)
+
+<a href="https://facebookincubator.github.io/velox/bm-report/"> <img src="/img/velox-build-metrics.png" height= "100%" width="100%"/> </a>
+
+## Acknowledgements
+
+A large part of the credit goes to Jacob Wujciak and the team at Voltron Data. We would also like to thank other collaborators in the Open Source Community and at Meta, including but not limited to: 
+
+**Meta**: Sridhar Anumandla, Pedro Eugenio Rocha Pedreira, Deepak Majeti, Meta OSS Team, and others
+
+**Voltron Data**: Jacob Wujciak, Austin Dickey, Marcus Hanwell, Sri Nadukudy, and others
+
+
diff --git a/website/static/img/abstract-white-background.jpg b/website/static/img/abstract-white-background.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c6b60317fa19cdfdd569c101508ad47e6dbc94b3
GIT binary patch
literal 132559
zcmbTdXIN8N)HWQ)f{K8Gf)rs!M5IQg_nA>Zz!2$DGe`+71VS$%j)I7x41^*zN~E_T
zNQa<Q=|X@=5lA4EP(vqy@I~i&zW4q8?u(1;vwJ;jt$W?)<lD(C;Ig5ffga%0DZnpJ
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

literal 0
HcmV?d00001

diff --git a/website/static/img/velox-build-metrics.png b/website/static/img/velox-build-metrics.png
new file mode 100644
index 0000000000000000000000000000000000000000..f3ee4694448ee38eab2840a06d4d3c2c471d5596
GIT binary patch
literal 103291
zcmb5V2|QHq+dnQ6k+eyXrM;|0mMlX_D%lca9VEN4#8_qwA(TQZStpd8A^S384P`6a
zSjTRdF~&BA8N>hd`Fx+>^SpjP^}PPP%pB*O``qWg@9Vyn_w~MB=<90na0zg+u(0sl
zy>sgU3ky4mg@yGY=RV*}7z8QI!g4^}Nkc>bu7-xF{u6h5Cs#WbmOC##fH_PIzaLLA
zfBX9NPgc%5`!V~^JYc=EKb8G89{TK@`lYM;LL!AsA9_e;nbd_BL|*bq5GpFZw2n2=
z*YE!pV(I^mwQ5m(ERm9^yu&242X!VXdr^c~di6ZMO`dwl_SC`vd+x#j>dpJ422mIr
z>rd8WpLnt?ASoaD`1lT5pLE@U;73`W=V6GVJ#>eiAjyP)8^XLS=eQ=X1qw^^PlmFL
z8>tkX6JbevrGQG1j<qofF5A10bNS}UPW^GQle&iEm?w!9C*+&*S+eviE$;4PagICP
zb!psAou?G^Jo#2YDklqUUlXXZ^4;d4%$u%k(56FeYw=EMbC0)lWTAK7wRN0mh^%aV
zdGF~Jy`;wE?VyaQptzA!^PhOdO|s+PzCJOSWP^9J(>wUiMyv^wR`UGL^HR}m(djnw
z>D!m%yI=c-sXDi|*)}Hav3#DqG4k}vbDq-&kIdY9CcatXZF7j@QN_)lP7MLNr<&l0
zq>oLrH;X~#?_OxRgiNK*ACcGoj+(kR9cYIYzEeD9dXI^VXN`U!VkqAJO8ePI)*{W|
zE2mi>$vqcZ{c79zUfz~VcJOeh{1K;D5`o;$ZTF^G2Ze!*UrX(eG#HATo#pA|AAWy%
z`qri8?XC8TLz;nw#=>A>wIpsIQ_)A?c!``VZyPuW4g7oeip@sDxNj{N-Am@34A?pG
z%_Qke=ZgnJQ}!WA)+gQf6=_3m<UNr{dCklJ`KE{-KSAr;<;f=Q;)+y*NWUdJ(Nl#t
zSgctt=Q&x+w6Zp=<HI3-nREMDEkyU6RA)K$zJ2`pE&mu!i0zHj8%NLVX%!S8NK^Qp
zvbF{ZJ>mm%yq2O!zK&_#r+2!O-A0rHuRW7~O9OwT?r1CL&O|b|IB#<zTW;RY*lOs4
zZ#a9r$N95DYpwbsCFk}XVS9eMNi<E;?I~j%;-^?cuP45e^^B?a4=BH=a^Cxp@Zo}^
zO8d(%?tghsP4oJ3@0(0fJE`u#c6K**IZMx=5y2b{I}3gVmV*`CYmE)aR0nYD*AJd;
zUmG^=GTdc1CY&yjTXi45S9!IdRkrE>IUzZL^g2=kr#7o~*kwo`JE)<m#&FnqjRd(i
z29`A)f5cH(JaBhG#b>Vz%Yg;O{^zAOT6TVpFx5Bcf*bBvSNy)FMlXqM??dHDyz|#B
z)m7ECI)>Z~ar)|e&06ocUL2>a%<4&r4b4MW6wjngafTPaE9PeTN_ja+rCu=G9#!`q
z#(J&pu+%X&>gwtyC>C>`EbEnx<gvBnVw(oN2r(8yg5QI?!6A)y{Hy`mS&hjVysv_<
z7Y46-?sKc--UwDd#C7JzsXP0Q+N{NUBx~0_ymGXi?fj<$5^TA3N`;4A_bAu76^dMY
zdUpJrBAZl5+qhB%H&~C~Zx6jrdFkYhLq~3E%smG^3Nbme{#>@<R={iZbEjV1c>Ctz
zIkv;6A3VMwBXU{e#~WCy{pWpy5!X&%e6xCo<B6dE^EFZQ8@)^64-BBaoTWFl((b<x
z3s3c&+k1^IIplcSx49$UJZ4dgH%Y(V&1tSF4ZXmsGp;_(epL1G^6b;ASLKht_+mZ(
zac^SOhev!Sa>fyIjf4O`QWLx=M)7dw)Pa#b1>=WQgb5RdOM@Ga0)((^=oa(k+zpKy
z-ksZ@4j<URzE_Vm;`Oao(fjA$9}?pn=8WLXoPZF|)SNx?qUx4Qn)1lY?@bbu2PPj)
z!Y73%_dnuTzFLI3b!PtE!d?95J4fQ)>xrGtKTkd*bkXuO><uU@E9YaDV(#AT&sonO
zMm`jK=#z8Gurh7s{*0_?sO#PJb6RgVr{|}?Oy^JAubh9vzbUKv?vc)NMw7wUORJY$
zF2UaSyhprO$jQmE&k@e~m2<PNGRNg1EhohgnMHq-qgk5%HG3-i0r3dYhq#{zB?<~e
z*=w$*fBCuMr0pnIVpzga!t3lUrzICHU<Hjf`(lO};wz0KK89(-V(GW2H>q4yHey^a
zLatT7SiqI1pxHI*UetxCL;+@kcZWg3n}o`QmvX+&DY%9HGft*X?9R)jk)>sh$=&e#
zEpxNp^2u5#y|H_0I+X4U&gL#&CB-FeCB81@F0^^a`HH!7bN73)d#~s8WWSs@n}6c%
z<sC;{#9>kyP9J|=>AzB6sM$yiw>-HHaj!^0rKqDHy2s#Q7(My{raIG=IYZ~6(|A1C
zltUduv-b%e&=p)eh!b9vOH!!u-q@b-Jz$`r+<2n#WVrc(;RB4QS5YBRO}Aa5bWc(R
zNCJ$L4kyvqK=vcHHx-tz9!|)+cHM0yDYeo1>XQ>LC-Pr`3^jTV8D`Jh_xSX5+4tKo
z+iTh*+7}ZI+v8{FXT>|r+Zht~C7R9JOR`EUZ10vmHnTS?C{uCS#Qzu)`{f*L6lzpn
znj+Uy^|Pv<p2E}7jI)o_DeaImPm}DCANIkJ?UZ{v`=ojbx)<N7I#cYWORU_-u7+G`
zuzluui~2nA;6sjBjbM%ZMhz{?7LS%QE&E#H&Pv|Scx3@vS!i|FEzrHLYo5Fq-7UbU
zl;iktH4E42)2TwZM{r4ZN)Nr=b#hdZ{^2F&Wu0AUn<Ti3WP)QakSwqo9T`3626Izg
zJieH{XtbyhKh%C{_R;Kh-jImemQyijg+)|HRaRALi0zq~@ekzEo?OH$>WTV~`L@D{
zM1L=g0>YPmCEx*4e$$(tK!1YFMT%_3GnScUo2s^hU%#4En@BU0x6W@zY>gGG4i*nw
zWG#F;{<Qn)x_W-yMjb4eH>5p8Cd4_E9%32luouO7`q{HE3Es-@S0|Sg<&v=aw4bJ_
z`8K_U1BEb~m<Dpg`H2qOUqz|5;8z%ao0F#_9iQ)glhn%hhL)a}o^eYk`oe83P4I2C
zsFQrMva_xdsy+`EItP3`w>`C|7Mq8gw5QCE^d4=#*n6%<@4y`iy@mS%@z=!XAAP;?
z^-AT{u=j6Yf0g_aWHDZ0G*#7H9W8w_$To!f%;{*S-nEY(WtZp9QSXl2<#@0^`$e|0
zVXep6%D$29Yr1AeW+E{i<{gN7+7x=4##zHY6XGzBpP!i@J&8XlE(4cA%8JV%!dxem
zCUWy$=S7)Piq968JMd1Qn_c*B^j)U|dc^6)SIzu)Q5W?RM^2aV$30ih^wTw!`=WQ`
z!eDH~v`(u_J1$&p1^Pg6Ub;Ji9mM{DT_oeeebp;EUI~t7!`{{NFEiA{4~T6+_kltc
z((N+l+x=xlIv;fmsR+g=%U9b)ZzfG%xAY1nEPm9Ak5i@4&Sa*oq?NB8B`EL<@^wiD
zZfP$`m!5Y%|MqPncg=BEi|5kEq+G48!G8^Dj@{e*!v7=bhu9CS#H=KCiIio9+fph#
zhrG*pQ2s?Q_Hf*b*in<k>Hw`udw-kFDLz|pFZywwgyp7B-)AF&xP_Q}K}KF|!J@@c
zY=&q4w;?;1+PpRkUrcxH6TJ^MeQ7x~(k2P*x-_g`{>#yJuvsthS)v>CAl||XYGhdy
zR`JEUttWrKdDnLHR=#~=ec4y2Rr$*@-^J&Hzs#l}hQ&P|gl@AEW3%C6m#u=fYBnE*
z{_DL^e0p`JtMq{QC?mj%h!tcsu9u&(7S2+3^e-eHV(L4oK2XD8(Wi@3i?3D|rC%<|
z{xX=m`O~JQaX99qaJEX0m-qbDA4QY4Y%Sa|G}Ix~oNB!1if7yB*y_x;x|S|cZcsHL
zANolAC)v!-ubskb1mt3?f7hxG|3`iSsVd7ncQ2^&S~ZChF*G_vlCHFJu37M`thBw~
zQY4NA>q2-c;IjgRp>L$aIAyn{u?m>iR!67#micJ8ms@R>p$B1gw35b2yGL;uLHk*6
ze4_IXtF3!i!Gw_~mI}!R3+dG{{xMc6-w`WcayKrMoxaJwbC4VD9Myt{z@^kgXf>p;
zjc)|}TQ#|zJh;>9%D7cvP$~616^40RBjAVGh}uphyIbPR*0iW<esPS&RYo^2UBoBg
zai9w0@^VjcmtpN|Y~H3bqjb}Jpd7(g$;S4m;F<UiU!ApPPtP7dj1Y^N42!oPDE*aT
z(#|xyL6YeV=hnqM#j`(N3bMeKc2ukQw?{|zT2qYuwnFH{sXfor_8cPY`S~k7f;euf
z6Ik$`?~DqEYvgu9Y~sFc9fPFnLC+b4<E;-Z>$=FbEYDT~bgglp8i0`Ek)6q1dmSAX
zG2ob!g>}yn7B=8$5Ae$p;l#4{pJNu53&1xE3)|ap77pP12=J%>iS@s(vXefs{ns(;
z!{0aFFx0qv7x*@`ePU<l=H=+_4fc5ngfgsZP7h7IO?2)n*}6leY#zHmvXk<Idi-v}
zqT;6n97659ZAAT`u5MmReyV5wxkCv!{(V~djOahNc)O^cG11W%)o_1eCn_&>Me52K
z5SOT^sLGSa_DT<K-TqH=;6K$fj^5rLO48E4zP?hvvQq9(9Hg&azkXf%ij1_3j3jV}
zq?f;&w~e2qo7dTYAM#(%xn<{N`^3q^+sWNc^!IaZ9=XH3RnMIH-O>N~`S(5T{G9%~
zCpWME3=0^b^zSRuSEa5<@7B!Q$^H+`eqZ^w*+1j@w>y>J4^z^2^0RX_z2yW2W)*lf
z(A8_#uBiOe&;N7jzu)xVrbb?NPc+=2Kud4Xf3M4b8voCW|98WG`ZW3PK4t%}KL5w1
z|IzgKAe8i;I04<+{GLV7RTb&~=iGnpSCRfb#s6c<|6R|2&H@Vx;!=_RKf(dxx)xNy
z$-<(}a`)Dahkkn&Mmatn)5Nzd*OH`I&zw1Op7VD5<b3=gy>G9Uk4>Gvm?8T}$qR&`
zbtV-*YREg$Da&!|+p|aNH@@HLd<%9Tqw{SesvYd(EKQD0n0Ltzj~eyK$)X0S6;`;1
z=qu2n5*h9<pFcPK`0>LvjL-P_Fdx|BS7c=50s$2iZQe)P2-;zwsxHE?Xs;fI(z;UA
zmsM{N`<}gr)LC}__{#c?Yl1H$Q)6>-a`HrpxHY(1%{vb(Omw-VrpL(9i`dL*Q#BU)
z+arFkN2<IAf4J!%Mp0v~86Lp%Va1bZSJZ@h8F~J^>#%~z=GBO3<b4WSiHns}^eM~k
zAMd&IuGluek_jW3rQPObUl9}jicqIeomUTy(O@a`Og2Pm_C~jYQp+%Z$<oo?NAu4x
z&mH1_gIn0}J9N{xBM0n<p4@}E>BGBbL@A!f#0*_KYsE{>t&LbCPE9$XLjLeFzu(d{
z_)Lc%xOGwUbTzS?mzS*ioTd*UI9idpmiW3!D%76FmL+)5!LmOONmO4-e_^7A71oi1
zD{Al+%AIyI$^?PTA!IBX&KI_pLkk?DD;BY-{c(8?sf!+duJDmsXjweP*DLM{{*~vC
z(xkw+MwzJ~uF1aH`Wj-l?S?<rNcrzebh8<2Enic{H7i#Q`Np>4eTAYu{FyO#%Bm4!
zJEzj;|7&wEwV?j^AEz}qAXu>&5?mGHXSIDn=qKV3+EDx6y-7~tC6YSfQjH$RN+7m*
z4LiTC$obdNa6OYi*0;ljE?dyX@ie|B#A|fEeFx(@k<=pm)8&*q4m;EX%}M{Gl!!i6
zuT(E$^^;CuE|NN2#x&ri2(?o2r?fz4Lq)U_I|GY;3KAM}QRy>?6$*Ch$rw~d;!B5M
z&gK#1vf>Y5i2tC!SKFZSM6pFD$OA96i!9bXxTv28o<3bw#x+xFbOQbM;JmHoMye0W
zfYLUcRZBCvL$Rr)ZwuUD_H?P(c43x6YMUxlSC-DYmRl;@5f!se2BWdUjx8vUH0D+<
zJME&0)0Ynm%Mf1kV*8G_7xhs=R$j0tdC8JP?l!8rs^<;CeW5$ptw>e+hHd;J$6|Rc
zxppToUg==YMg0$5U*TuF1$SST9C7`;E0(-`VPvi$rb%!>zFDb^LUQsor?(yPvKQm!
z(AWe6%#d^Lw^i>v&wyD>^Uo@ptbO~H4!lkroJurp4Cm=FdRe1pN4zGevcYKI?8(&Y
zI<=E>aC*IwSMA}(TkwI5T#o9YQWx-m!(I8c#Zl$`M5@Z_Y)3J{YAZ&__dadfiO?RO
zOp7mZ#Gi3OFGhp9M!Ni*J1M;l%}FZ$ksS$gvOW0~6;1sn>HZl7KkH*;9fo=@8?Gdn
zl{$ae>X??>J}8#6V!C}0zfbz`ZleqyD^<7H*TM!z>7eT@ZHhP+mHIVizU|aJrj7Up
z&FZ+<lI49m`gWpWcs-6G+SSF1RVhRU%`1Mj^E&Ci^7vDxEbNrTp`V&>q#}fh^bcB|
zb1G^U=r7X|WVF4BFemlr^TTy@ygw?q2jZ`+5(u~%7(GgSv62QstXC3b(T~2R@sYm~
zP*MCzGCbEg%JJ|-Y9NR~=7ISWI&eB;5++CN<_c}(A2qc;o|~OW<R%a0qfX(PIw{oR
zyce|26T4~$2}#x&-#8w0EAAuh<U0Hfwj`<nL3YPbMW$S=4vn^0l6E#(#3dzlVzJA1
z9^TOrG$x4dcZ1N|1=VQPGgS%BHq0CXTLnR-w+L!J1BWfivxhG2Y)r+xRB+_$1dTsk
z=$54?(a0l}Tn<u5%aZq9iS8K7dF~zs4oJ{c{ym1oi)M!u|NhSE@rLPNjLHRebb?=}
z-F$K0e%|I?O~rWmq33Pmb1zB@YFK^Q$!2BE8t^{Gf?prHe6h-N^TYRA368YaK8quj
z@=J;CdCb|wmXn)-(GfdSEip0LRem05g1K*UsVpfmH~Om|D_63}JT(is*$4I^K+7-i
z-#hN!+u-2-3yV=@PEW1RCc1z7;<vq)DU|P-emhKg=b&?`@HUE9<x>Ngexo)}Ue;kV
ziAx!04an)M?D}6^yrp@_*s!tlrMpk}C}8FK`EnSpe(c1A!)WX6OjO|4w{PE`py!~3
zmGG&J>))S<<``~HzLbWpcF4bE2x!}Gd}O<6u9OAN6jJtih1@iN1y{j{1N}i3OC9?x
zP2#Wlf8`NSQ4ExtH&`<b*!ZPY*3oaCnd=f@)kfKxX$_O^Gn~?^*}Jc|{OIlIQ>GI#
zH_@1N`VqhWFy8AqZyCoWwia?|Cb6KloLU$7nca+H;TmUCJayjMQd;M9H9yJ*U1-VR
zS}q@U8$QvW+u2BuQQPc|Ceq{l5{Po)sGi!OAQ7oSw_=?c?QzG;aYeQ*;hx4N7jy*7
znRMzqFBiC0J#AzE(FPum%m{a$Jo_j?g=k7~2Fk&+rH4c(811wkkPY10tGt?5OlG8N
z$Wk@J4_HpxAZPcxY^W=QBwz6ik#p}K5x8a|7Y%XPKX#v1iW@6j)Y_4wB+t#ZBI(#T
zuvIb_GkI?K($NOW;13und~E)L@kNV(?7TV3lZB5(A7I%&iQ5_8ZyZYZ@#NXH#rA>J
zXnQfuci&xzpveykgflK)gAQGzG*~QNSLzSaz7T=CdUYi625E_e=RUTp6BFwY{3wjb
z)p_g!{0{oHWigSj9WgF-j!a6mlXdRPv8zhWiZ%j?T&c6~N)aN-r4Z#Zghh}mcSqn>
z>|TOyKc!OQwo_N}eyci&$?us{52WVHsQu<G(TWQm!%&>=cdv|Le!HDqG{=xEpzP5R
zUo5&6wE7OLtI`HWx3>sv(EKu}tcDADrAJq-r^Gm*D#?3tEN|+dP`8l}iR^2F0#WRV
z(c3Nx!^m<=S=dXjpCwL5mA94}7gmBS;!oNeZ%908GYC>uk}$m{ZOB{-Rh=q7-~GWM
z$v>9)`sk6dCp|pNXToWSt?!v3qs4(I%15J#0;4h?`c(XY$1iMiz=y``$1XaQIsR&h
zRxYc~r)xW+uJtZ;YVRNi*ETmO*}P+fQLN{SOKJt3KK*&7>m%IKL+|ud`J_NmZAn#)
z>%+ruCKC52LaXj(Y`@4%DWi=c)WV5oLzgT|+_oJigbzc!$0CF?Q;zV$e$BTQjMiLs
zqg0X(n%jLanjGulQNX)e@t*ovLaU*r_!SRnZc4~?a!YTuK#*j)L{$e}nT!;dm+Ohc
z`&)z@pu=T%iAaZ$3Qr#jQkC3?vr=G6`a2DMcG_~kN$5ljt`9>AeXfUh(?BL}dm~lf
z)1F%1__EG7!gz(?l{U)UhBda2=a&z4<9UM98vIJdFKzk!{Pg(psi@S_#g-^R5siBy
z8ef&e^@pVoRFv3DTLpgm&`)F1Fk;0<eu(dOaV_!RUskV0;&B)nt%QL99kL3VebEry
z(2|KF3u*KN!#>q7qjqJ#2iVN%{ID;o(|=;4qa5!%>{bjr5}=0ysakmZi5<P;oc$)b
zVQ5j#(wK{1_eonu;$t@J(ij0brK5Q{x+p8RlSgmP9Jaap(ff^Q)!gb2vaHu^yLX&3
znM9ijPjrj6ue`W@C^n>Wy1Q)(dGN{baasj5QC{A4V@a`{*S2|p-zx9}e@gAvkKFG)
z*UXSGah@PHdH}z1_%nCqB;V~Y`6s<uA(mrEiYj6!G|-3Cp)fEz5y%VK7yj}Nvq9!|
zSY&^P9y+;p8&0|~`uHOweopW#ig%--vvw)1ot=ZJT2N_E@^gcMv@Lt9rV6U_ap^JV
zyAtug6dvLC^Jmf5kz-QTYiCF$ZBlo=#+CxRszn(}HJ)3~mM4ZKr^xxf`29A_GN0yo
z)%!uxf7qz}!DrZs!cAi8xT3P{r8<Zx7aQNo{IAr;5Yy=)S{<!Nk8v@ztl3~^k5#~7
zNleVavbOl^xhKmmqI}H4ZXi#M$BC4WdS+f;Gf#R#mBS4oPv_~?X55^bZ)lRkjau`9
z);u!&V@7?sgBLU6mDne`RCfX%WSS1m$2U4FUT??Z6plE5ZQTG|hxaERj6H8n&QG2%
zJSIGXq#)Tt>1*1|MaJp*MuEXGF$?c|akz&2%ih0aG*B6_o<shG<om@l{Kh5QOwX2`
z{Dx2XE?oPjmvqGysm*DaTqRRxq;~vk+s>Q)M7h93Ih@6uj7lY1V@FbvR<kO8fY`%K
zyar7gvARJ$s}&u|Z{cm=ZZp${#+FSkjq&at6Scile-lCB!WkXQxcuIbGcV#MB5a75
zIXSUyY`%S3n88~bbff{EJf%qxs{=2u!a|2eyxb4S=Jd3s`0bDzkBD#x`KjAOp_tg0
z(v=dOM`GB(s}VQX@Ljd9ePiw0U9yGPM=LdDUoe8!O&{dbVErdEha+uNnckJPgi!g5
z?LXpz?PoJzHZavBXY=4u%wH|2rU)q$6`|PF>$4k27eaZ}?yG$u*N$QP4nC4)+xo!~
z+NkqHB;X3-Mw3;DJs4d@43Q&Y3NDnJJ<9Y<?|XOJYQMr;9qAWqv*zx0QbflW{FY6C
zUD)E5sv39_ccz<SLcpw-U}z(a#@S%$lQ(Ji6d6gYE3DMdjgJ;A5RFms@f)DtedK=H
zsF*v|cPX%Tfs%mA>&iCDja}9c;*Wy_cv=Lu4DT>j+Wdus1|D%MFF%_i|J0~@jFt2J
zuF2n2N?}^;9;`|5vR;ihW+`}T3IsTgyo;~}+37wlC?0KEad~>5&FH2(c2hnja~<9A
z$|T<$ZTG}GuSH8FD9Lln_T%>?Y*9w6u>WtL6O=$jOi^(cf|G9&r}R{=?q4gtAI0j-
z%OQIa{NxiZkcOenQU|<fqvWmC&KKGPb5s<+y;9JI!6vDnQ9-~n7Rt=sbUQ75M_~)&
zq1&!8s>`<?WC}jV9<r}Q_mxFO39Bk)<2s#et_#&#zj4ZHu7CF8D7jZS6ATY;7&p`d
zWp{(L&C?eRURTRAh&+NrwL4V3VaG<EsW#@;Y8QED8yUqTay9L?)pm&oC0I9EX)rxT
zRk)>3MoQ$FI=m%XxoIlS%KyASC_fkS;fpDrlcwIvJYFX}0b+MR!7}n|R(^Qa{IYRE
zY4EDa?BA{xk!cF&5j-w+BHw{ODX1VB(K+aO{iG!Gy;L%7sI60}c+0nL$G8XC%?Px)
zfky5y*NdVjkohOJqjSwKgpXk$n3Xu}FU_nrsmj*1F*d$Yjz@R=q$|f3^pRC_tnE}B
zBsrkxR*<b(OQ3~G$O}1A&x3`tyZA~H(yUiY4LQ+;5(@W?EAma(x%SFUS&-*J%G+O$
zMHfEY>FH7n6EqDJ(m)Eu?7vaNI_v#QN3KUxcGT;o+sa^xQ_p9!iS2@F?|aduvVK3u
z+dYjAdQXVbE}(cCbhK5oa3`vMdJLYAJLl5Hs9>rwMs82<{We;?)8}10;_bgwAMth^
zN1|~l<c@lT@@#p$fKttd+<$>&j|RL@HRa*S`x1hOGsrc+I#rk@=d!@*{oXi*ea=<)
zQ&g@~K&*h@?-L-vP7K`_6sI!dRt@|5-SDfzaa{pJWeiH(>fqhJ1gF3)&z1`}FhsNP
zlT7pQ_?h_?OU_E8HS#+kIy1i;?CyVzAAMrDSD5h(%Pme{uT%9MbqgZ<ywAt<oAqDF
z>p^S5esD`~U!;WGdv`l(Qd5qXD2HzrggP?F)q41!FlY4p?8MEf`#lNUkhQUwqrRhk
zfN#l<e)MuTgrx4tdHrc^{G6ru6+;hn+7dqQnSmoZB9fk^Lx2j#W-r^i3tq8SU&sZq
zHNXeweW-&MMxM!8g0`pMt=U)zf3|7tyDyvF6H^5vJ*Fd9I~3xla!$=rr(-P}^PI!d
z=hIkfH9D*4&bSV(9!>4|B%dGO=fx6_HH^{lJEGY=-50r>gQ8^Q+K<#uihu{Nwg`#1
zEhsPI{C<23jGma7EvRh!){C|p^BF0cb#F4C`$il-B<No9M$TzO(J8RpeXQb`F5T;)
zZDt_^^GaOYi_odF*fY+QA9g(|s1_J7OEaw<o_}qQ<j9mduu&;jMD`?J?pLI4AGd1<
zobGFsk^;+^SNsQ71h^i$mXpik&5-XVKicXQdNl}aP$FvinY3rS0!wu(68Z~mct1zL
zQ~eeSCyRT4tBEQlIDb-Jv91ZF+CT;YA&B)VPi#y*s_kk}qU7{!ikTe+DSSGmVDIX>
zDx%hz<a7}=)W|D7a**dVI>ewus=zs3(dH%uXPj>~)0dq_O~_v*UcBF~7DOwod13z`
zNLcE@F|nZQlS}R8d%39D&dIUio8~4{=9&dxA6(k8H}TQr-(TanKeiU-n?gOHy}j{`
z-`#wu?A=AZ?})pSW_fQUzP-npH1Yx1Mf7b11rs+qwi>KhB_%v3%#Nh5-A#d#%b-vu
z6&KT1bM6DX&jp=?_uyQ2yCje9%l_0#zR=?n!)GdOr-ezBbimo1F$OdI?stx5@B8^y
z)kxATkdUeckB`Nyq}6RFgDA~fZLyN%=Ni04m<Ac$syfXZyWy7B{zor8*eHPItLlR*
zNU|NUVpD0X4<@<~hx=j7Ng(8q6Wwd0PJeCQyp+dCaU1rGh$g;0#@=aUYJBec>C$ws
zAbK{u*pr*Rkw>h;-zk-z%^s`%i{T>Trev1oXt{Xypjw`O&zZhHZrM%c2z}ESq!I-h
z5#h1=N;q>+R!`N&e0zd7{wk~yUp^Li(XjlQ@O{+PvlKhIc2l!UXbm3Yb^!N?&XAkw
znHls59q&@xIg?F1Rb%9>7y9EzuTzhhOF;<~zvcg-O!}T}MX2|zyN5yZ&oQ&qmxrqK
z!F}CVEF7z*%FHL3r?`^S5h`1x1eZqDlbwb0J(>K(n?k!_RxGS-CF*Z(`l68e`nuoZ
zJ}>=*P~m>+6r^{GJ(=#$RnT^GW5>?K&AvCwKz<_5v>9Ju=hdyrB%#gJERAN69oP;_
z0SB9l;woK|RjH1tGU@8f93FvbSYP`(BxZKZ&rrzWnJB#V^$M(VRkt8D62NZ;Z6bWW
z3qqHCXGr-3IjQq}l`h*PyN-_r8?vTHqz9!p@=m%r*L-glyr{R_S&e)rH&i+skf~eU
zREBB{%l~nYX=I$8SJ_?GoQsAyG2Hu3?C6pRwdl*-rbjN(sLq#DQfQ+t4k-WI8@F{Q
zXiDQRr58RM>S|-_-zo2F**(tBW&MWDi(-XIdZn{KY>@C=d7(^(Se;>Qhy3U@Da~}j
zupAVT5kalU)Rjir<SBK;y79*z{w@jNR2_M2*n6DHsG#-vcEEch%$e8{<%}|~@pOGK
zf8wr4BHJ3a!Tgflvf|C%Dycp_2<eB@%RxKz^3k9%)$iqeT-4kbN~6yd%I~*VR=OK-
zCVRCdUH7_gv*T`*AP0R*>z!(j>d0ltiLFJ2N!R|s$EkN!Lo2#&8acc{W8vGB=WaOx
zeILLQYm(F3Ad;_2`J6AY{8C4PLh*<@&jBGN39qB$IW<zu0_J8No9h@-$sACI<$xD5
zg5~6=b<Z$7(k(5g%>dV-yKh$;DOz}+yQ#$dG^VRi53NI)sNSn`?%~rpWGVXOqEH#P
zLd@3rEO4!!8rdC1-BDq~c}5&$Z-kAG$XZ_OVK&BqA}7l1*THK)U3BBNOk_u^tb-bP
zhGvYg>vX~Inw;*v4=%b#l$LmDSNjaU<bk8mwVU=C=73N4<5ZBEw_}(rMOKJ^_0w2{
z$V}AF&v)fH-5*-ZuRhy<RF>d${q5a%KXA2O*Nj&`=?^3+-|ETO<k!CtPLMv9kQrz9
zLn!k?v@g9Unq4|)p_CwOB#eb%KI8)tQv9|^z(%SLciYs%wdw`xynBHo%c!G5`2mY(
zg5reeqDw7;&_Wx$6K{mv9MfFUKZ;#!tM;^WHzJmnTt4a?B<{gB8>7Z7spEWjdKb4s
zv~Ypz+4+3%bC-VcJBCXcwx}BvStQ>p#Lo;RGU8C~6tsM_|JoRiR4a6?m0pv`Q?2Yh
zfc-RyM=ZvJgJ#rr?8X9>FQFl5w4O;yla*DKM(TOD+dE4dRWG6Z5QoLD;!_u2l`B)Q
z7w0pJ(3nNK-|En3nFZIM1(r4SSvaTU9a2GUJ@1rHi^q-0h2qZE>KBW@1JyTYwe0Bq
zy}|txwbHM4em2HT^Hi=6x!4gC_&A#>ltEeiXJZNj04>7L-+>RbTlIT(CDm|p<R0ft
z)QUb8fAa1a=YV75mgq*fp!>l+zMDfcsIbJ6^?>pE_DVVACyxNaA<@h>u?f(gVesm{
z{NFAD{P_lrN?Yyh3J7gdp1V*l5{^(lCKiU>pO(nMUp45Gy6W=PEk@O+OVI7shJ-X=
zmowZQ{C;)o;YK~uXST_}4r{9t8XZl6)93Hkp?9KPt;TD4xXs;KQ8ALcE3`=UuLpFM
zUV}YI#RR_B2u?~pwid`ImEM0ILBnSp>Shb<z`ECN&f?z>I+xMqgSOJC+(3%Q(T8aj
zbG?7Nw<sN2F|p4$Qx__D-MNHHW~4-&RPL9mo_;i}N(lcHB}kA~>t<9Epk^ju#@m<D
zk;Qbm#B$Obt$`?ou}M9?a$c2<*BEO5a2dXeGyrC+eK7&c&`?y&A-##uae%8iXoT~$
z^}^=6&j<F5Kf7YM(cRV-ry8#ogk_S5E(@`VZmnKF4ivr)6=~>J;ShRavT%Ml+c0Bb
z;h}y42m^#I>zP8u^<If(P?=8Rj(x>`vNDoxhA|@cZA7UG@|norv3E#DMkfb!kL7hp
z%l@q1DNRiFTp#O^9>WSN{ya#0k_D~$ep~+P2xFX4C=s~>vQz3`s!y>w&J;&uQeIUt
z+^WBIUCYjD=oGG|xFx_qPER%!j$t=v&6USLNtJ;)F~cQL7kX^nl1(ESKsCPlPtc}{
zfILOpaY>nU1)i~2CY5fMi66WShZ}dg`__Mwaxf1p%$&PeZ@}$82`CQurSm{vdYqlv
zo=Ce})tX~fF;F;oL9hjv%?&a;?hF8aKGfPB>G>RPYrwU22rZ~Sy?4E<nOjuwSuOLj
zVdh{Py5{ZLYBCR30C)57!0sTZ1Q!5;auJc&xx*H@N>!iZ`bFjsS;54V&^C?XWp_DA
zPZ}Spxs&qCz5>ae%A2*?QrIh$@OJ_v0F)>)cdu<M*uQ7&s2+$f6wdR6k?cE@e-u49
zSasO3>e97`AG4m0wVk#+D4%~i#r$@-;3Rf?)*L_sLbn5~FKna;NU@B-z?-fCQD3MV
zeD*mDWiFYDN7aP4R;GHknPfF-rh=sr8QC$5laYgO9m2}#8|c>>56k=X@qwrF8E9Ao
z_XpGt&FeyzJCJk;t1_xCxKVK$4bgU+XKXXpVb0h2NBt^(F2FmMf@;SiG6ttBYt1Wd
z`+Jv-&E1@$9w@*iucZgrboG6z&+++Y7dOiUbtWt0yx(YzwN`A#nv=tJwl3})p<7UD
zRu^k*sJ;U;<Dn}=Ib8|?Ro;T~ld-5HCgQN4#iT0d&WNw^!~zb4Im+WSxn~=7J}8cY
zrKMm5i4P$>L7~zZ3*lB?k*f{D04{IoxBTVTBkKzFSSh;YPt27|yIWg5R!y#PRX?2Z
zM0JBkSUTJ>93z~AGlmff6WLv@lz~(Y@72}r=fh!F`Wcxdq?LBh2z<4p3;?0vMqh?2
zy$H|Z`!!^c0t#-f$v%UZ4GA1)wcbl(((Dib*fe=X)*tL%;Ek9&ZMjflsN1<#xmr-Y
z8XI|?D6MrN8Xnz)NJ_Y_#gXt!?R<N<)dNjb+u;ZidjP%Et55VQ;IsGk1#p{tC<ujS
zwc~5_1(`FHh4X5y=ipxe1#CS33}J42ZhqlrZpn!wqh>qat;RM*2ezQ#lUEU|rQk^o
z*&qC0N_hF*3iivk@r{7L9N?kJf4uHx3;~Bxbs8u>nlmq@ixnL5v#fM_6?hcburtjh
zov|SklV4%Q6f8r^$GjMpJAJdiq0?N_V*D2+MCzgbu4!JAl)aHaI1;7Imn9wm9#{yj
zX$UCIMXmQ~)nkT?9%iNu{>oX^%G;W0@u}KFzIl&yXl@iq5b|;6Y{t0)X4sv*G?S*-
zk%A<C50NeEQYBEz3_H7}1swf4mF8iM-Dl#$zjznaY<=B`dU{i@j4D$8Rj{DC8J+~c
zcR{h22ZT`DxjB0bgBS8$_?SKH{Z41{?Zx?fk`%8g9fi!?<1SXkNjrs_2<5ptHgcXU
z+@uQubfBwL)NN<(oqBWZSgT~ho}k4+hi|l8+B=41*vPh#DqbOP3^KPbtufp_?vS%E
zXjr+S<2Ec5BANJJiYr&TcI`;@MjChHlY5C@5@TBf$wQ?&wP)cHy1&MnG*l@u{Q6vB
z>vZ#9Jh3~}E^%@y2O_~uH__btG^sv?Hn`5W#nX|ZdJ$hEPpdf(t68if4KZmWwk@Za
zV3!Bh@n==hv8C`&1dNZj3I2{9b1DDbuv_KeHZy3aL`Pw?2}ld@k$Th~;_^vW3olyW
z@qzq*5O8-^@n?cJV=pIx=N8*0=1e96+zhJe{vPN;10)|l*H52fPNf!Mq<q_Nwp58;
z5tGoC4QzN;p`u-!(Q)4f>&8-5nC8_IBjVl|!CP)xY(GrQRVeY9m@VY878k3sA$%;d
zo#asm^J;%`BrjdC!7SNTIv%IJULrp`Il<a+djiX1_QUb+@lgq%jU^j-o5{~h*9(rs
z@pQ{v4~q;$g@;i`w05ox^_w~**OZQMCl{CCzR3|A%lBWnpJcsC=qQhsG;cmh{J@0F
zVlR%?7%9Mn6x@>Lo6DmF<jTsR!^gJFJ5+t|o@(j3yp^nzbmc1kahc{zxrQ+(l1I!7
zr4OLw&K{mPs)Ct<L`+|eX|adlYzDi=);*52-BY!8cdWw-@!s+Hm<DgF?%Tn>N_lz_
z8^lZ>%9MGZcoMECCKDM(6`N<8)bs9|%=veJJO`3>J$#?VU2$eqC1ZWG?T3+kVnA6<
zx%g)q9Ewz-Wah^lRbFA+EnWPdb4P;xLQQ#x<w7AhFbzI@lHgRW#aI696k)9RbDHTY
zNEd!Uq^<nBY;ovr=*EA}8Hhe6bH`@?GOn+&$L0F5pbpNemgv!bUB?DQbI@{D(^mHr
zEkk#AUj9*-o2;Jp7*-hjGImQx=@U&9k{SE{ebZr;aa?exfgkGNG&3M-9@#_oJQVmh
zzQZw2Q+h}|Rp~*+Vm*ce3_#S%yd#0;)r*T!{e)A*7a&VBhaYO~8Y%x9JqJGl$QyXx
z9_=wltBINrU)2&yDu!b%FlDIEsvgU+0gAQ9=gxiH6|?xyWB_9^!?61BLHSy9FFn?a
zSeqYQ7H-W&MJ(a1U`l$Lw%L~ELD2(se_Pl)dn3C~*F=!;IVac5it#TwR+Wqu(O#u}
zui#W8gXCrdYcvuShDPp=i2rMYrn!%0hQin>06U0evIi5b>Wb@kXv-Y#CU0NM(T<s*
z?w&pRH>32);?vgR*HkG?fDYVhR89j@j};bkrVXwNuOObI;bhV&-eoyP%KtJCCr=rP
zTS!YvMwz2{fG~<<(d>v8jBARoiGhvS2uz8FMbon#$6B8AZS9uF`p>!GTc7R(SBH4B
zlR<`%8#U2<RpOt(7-3>AeeIP$IoGe6g1~ed{PN#Dney*OY2|+|OX{hw0^DJvV8B*T
zn7y-mYS&d?10x!OFQMgwvZVjU3i`@=+E6;OzM2&_1|BGon?)L9P-*a>&v96TWD%EB
zz+2p*kU<B{|FTyv@n3py3H=(R;0jK*@6LtTR7Vnf)r1CeV~9PxRO;$Obc2lIn_!V$
z9f*H~etQ40O@TFMgTjI-@1;eXnjzJvv_d>1H^%-KzzxC*v@l$9L4TixOY7sK4%oQZ
z*ycirCDQ2>v`^2Rmxk$xc<6x!{pRo(BuA@O(6E0O4bcLF^l{7LF`)l(NNP0)86=B$
zXaj~+)0F|n@JCJAW`rW#9d^Y-|FcPESicP!%`M)*ltEOU;-c)0dNY<r85`GyTN!z9
zA;wvu6_Wq%rsm)M|C;a8gO7`;HLO0oy#O`p4tm{Nq|~1iy^YU6My1;Ft}zE%IzXyg
zf1XXzLo#b;#4lfdafEA-uYu7m-#Har?QZm2OsP3NSYhW?c-Xp9S0jS@zfi2++@yLd
zq7G923tHpD0^6-7Vp$lUtMe_UPY(tW5!?*^i}rk>{$}iwu^fmo8dtG=k|z8k7tK#K
z5Cs%ZR~F54>lC2K)#Co5JUQQU|91R`__AEqt6BZn7lz=;(R~?#L$v&%Qi>)6^b%rD
z)j^S%yT=XxM)Lqy?2QlXtSLaAV1cv<w~Bj%4dx2cY$+rtXbNJUj80qS+aRR|;uYlo
z7klz3Yz}LW3GoRdfixftF)j)wrraf$#mYRHP&~&sfY3*KAtf5%#S`hx&!0UAR!=l`
zdHD0D+^&%=r)Z%o_c8JNU|>3m2}Xos0zfSsT;?KUvN}Wk)xa>}X~w|()3Gi~NcrCG
zFg1Uv$H#n9|G>?Q<^8SO<Io0K1%;!bh%mBnH{uE!%QXwjn=D=~Mbo|2(N!b1eFnQa
zpZ}#7Me)}Cp}tT)tjqdu`*5ri@ey^9*q1R`kBv$7z>7H3u3~D5f0JE+>X^rZEh)KX
zT6KG(Iuc-9j`EG?qPpJVj9bKpaIXSBcqd0=bg0j$M^gW6?OsbCGW6k{<EwHp#zd?L
zV-X&dRAB$%Jc#MrTx-;ySUSRry1ZPX_cv>or~byiM*J}??X@LrJ|bdWxCwCy?Nx&I
zVc+1I2dJd;6SjUBHIDy9udRCkbVvI>lF3AMw9%9D977S5B-&>TjETGn??b3Tkx2u8
z(`%xyIhzFA;R6N0!V>w)avl3?y3%M$VT;@PBJ9h~tJV<M{M9X$v7F?;nVT8b)3#Pu
z1R>_^s|l6>lQlr;Bkc>c8|fX5wn1O@P9fIJ1%$wH)_>MY>R9z8Q?$C}jT-5ocL(Qy
z06P2p`SYH8c{gC6ypG{B+5FY4Y~f?xh*Qu0qNPO-vEPivTH9lyj}-uG!r+=zZN(WE
z&oWO@skXdxa?#~3R^)m4|4qs|^Jp3!f#9D79srez0LzP5S1qAE#djH2)5Qm9EMqO*
z?Fc?0!@r2CsFkR0F1W5BEuYn&FKl7{H3T{z$hBak@{G2f)8j8DpiLg4R~G#*D|76N
zh955uV-#G|pGTXl2h49L$pR{uj&DTtIh|r(AEKFV3|YOGaSx1F-6kFrRQuv>plc=7
z8L#YH0Pv=yD45Q8*%r5Ivb>-w+#4du_eYJa9i#54WCC6)m^@t_&G(Zu(C7n2mIYKv
zjxM_E0TNIH8Ab(46(1ap_?)}4j<5nEhmXu+%Q2V8zJk&;GA+|+l`hf6$2AwDM7)Fm
z(kxT#Z|PLhuv2ETJ->xVaDGYmz4cMwvBA3+lOMxK{iSZBRgzr~YkdD;w5_v`UqZ=?
zK<wdziE9t!;T#|@2!m^)Z&8-a2Uw{9-W}DSv_eQRrKfleEMZm;XQqD$e>u~C@#5h0
zyxQ=$mTOcomlCrgIhTizq(^%JDrHwq@8_<SnqnLT@vUnzAApglIIA%_jp9C9?OQJ7
zJMznC(2jrDyGIAw@N9p7h3C{v{0mz2A54b?mGv9wEMx-i<m7Z<f-mQ{#>Q|g=71g1
zwov434V^ea4vgm5CK9@)&ZPe6cdmRZV#b7v4=q&gwDtO*y@Anw@BTaFLLt}VRhOHN
z_5(z?fkHwGVn|^uz&5wQY@26q2>prd`X7WW_>0k}JAhBM$b~DV1lMpZ<<R2S=08E)
ze>jXFs);2Os(_UyLGoTaXw^Y^JI7$Xqp<S(Jpb7Bevsg`;cW)qTX`kzaR1E6L_dS<
zRKzUhbr>*+dsWh@8a`-?zJIrKSt!b@9%}1a{w`vuXy=5T)xr2F9r>M18N}Mm<$iMa
zo3gI?#)Th<mch^2+61#rvrLF)+vsO)r7V<;T_m}rN7u6%Lk|E%Vc7&W-;xWkd=D(I
z_2>;3R4+R72wW?avaEXC-+)qZPZ<pW;1+<+HZ0(hXVW4Q6p*2M@|n;dB!eZ`c|V}B
zGD2az6y!1Xb!RY!W|+vaHAGX#J9N3^)<MimH#LyC=7C&$=uhicUF}V(@ok?bR>@Ub
z7Y4nM_5(K6a)q-|kz^vr#lccuy~0fVM>k8Qd}mULSdpM`@*|DgU8_B=(*v76L#4KP
zpDS9W)UYq|2Wy&i>9~*6v!(8VYw4;hE8fb^l)i=Tsf2+M53k{0M`Jq+13Tn!B|7qh
zP0`n9KUUZyS1uSTuM)b-f%MyOh8{}T1#E?cDK8W@zST-rg5_D&2KE<NRu6116nB~7
z3M`=va(TIyuz%A9y%g7K3Kp><$z5s%>ofAf`x6GIV$|G<9lFX=H6k)n-dO%|dNdDT
zGR`Vc2du)n(Xp=#fz=^!HIAfcNzk756NySkQkP%j9fqWd3-pcY>uSd4Us?-PF`Ars
zaN$8RX>jo(Z?TQ->~KeryHn}S(e*@Jv8wJ#duDAi)Me-ENM~ux{X(67$mPAu9g~j3
zt`EAfB68g+2t<{Tuk~33xlyFi9|q0LH-1458nB*8a<HsAhzi>F2N=$5llT2PeAITf
zR-t1^TK<xzyi0$3wDMxbK!Kfir{dIsY9Kd|59o#rYpWaEwcAv*-#atd14s1Jon&A9
z3)yA9pCW$a!DTz!jFziD12z#AGaP^LTb|ZU?mu?<J*^I}fq<%7)5b0J(v_%s9P0^C
zG<{72$yDjf?R~6|UY3Vc`y3#a);gO|u%;g^YbVUazkPzhc#KW;73`WrPHtA=m%h<f
zU1P|`Mb~Yh0YR=<2vm^X7?AuZG0#wW?|Sh<7^o-zTKk;UkanUxbm5&Is0f0A54Ok4
zLTj1p#TXiXc((nr)lg;{?b9cS>}u)zs2_E~Y*VV-*P8Q8izm~8Dw&~jclXeJJdwz<
zQ6F>CU~#7E#(3z}k(dvEj?7G40Y2$mWpMRvqt=4>W#?R@T;l^kOaL}Pr{&W(R}{Hc
zkQtaVVY*9hk+V`^jPzujh&T?il<<TUxIGr~lNqspRYTp%o_`c{+WS{}O^H=deHF!$
z1{v+$se-&)Si~FVF|a()TD1>jd8J#gzBuS*0E}en46p=yl-CDr$t!Kr<w4u4C_Zd!
z90dMd7_o5mH<w~1K4AG9|MIHya2XWupP++&G8^yE{8H{>lE+O8F2WCSbP1sPzsdg@
zN|2~hFY0<r6U6{d+P)=$2Yad`)`^7R>IQ%J)l6eGszG9znD8`U-H|~rq3Qd+O~B$U
zH_J2nmwBl&()G51$o-!ffl+yF1w7>MxQwA%k(6Wh13O&@i6v$kJKcVwQ|U3FA^JMm
z1zodpFU*Gd>ZI(WPeBu5{6o!x?nyNtj!T*~b-7HpzUlvb_uXfRGX0d%+9@+<Leo*b
z5<ptd7Q~?wJLwBs126vUi1ZzQemO717sV_9{8dEQqHqag!5?LbhEu6_o)0OSQ=1>>
z$MM6!0Fs9^ZOHT^2)R6MtC~r!_?E~CMN8vs^T%40@+vY0sfr*Jo6cu^u@55lX0Ol0
zS<PZn03Py87<pbd&f>|7-&`l3#Y#d(?$i?n`T;Ay3HF{9h53jb(8hj1%RVQ#Fd29Z
z0wMQDH!@iB*mE1qP2Vt*a2~^i%bl-VJWo=pzkQ8eA&%;kobH9eJM<xvV{*6WuZ(r=
zl$LA3ARY9BA8pY=if3!kUn``T!>BDswa#r+hqz?%OUelsz*g9rU3d8L3gtTfv$D*-
z*sONFEw6jk$(|7lWDFGWe(As2H1e(kSE^@X%^wW}E&+h|sdPXg7VWU}TUZ~xaKG^I
z+1pJm0OctUNTB%qxSZK^a+ArR#nkd9gzW%p(Nr|sne3t^1bdHM`=zy9oTTWP=2YWD
z9^wm-65ExU`#Xrp0V<tjX91N^2cQ|O@UR8p62v763{(wiaqc-GrlcD~XfX;h)y^Ok
znB&STSAQ&&Wo8W6(e9V*gw+L-jZ5=jt7iRacO_kpmN{4`^apZLR|#>Z44+c+0GqLu
zjI{k#t-kh++ff38ePAo7DtzsEy3?ir`#RucNGs9-mqSEj!|gh$-6e|gQmU%8w}5eU
z0kD-BGtiQAZ~Jp`IxbXG_rm&p{Xpr&29&FmQbj6Qt_jh*eg03nPW=PBF=ugR+p#9G
z61}cxU;v3^C*up0_)uX$Dw0@&hJP3VDr?>@iiig`icDp`HyiyB>H6UVxV?r86Sn+L
zJ0CL2*JxW$>hv~w6$%7~CO}Xq(aag9*Y{QtFgWu0%2r1;QI+<i3V^}}r10Iz2dL#N
zgY^5_699Wjt*1<pL;HulC*&w$*VGsg;?~C2aoOyDFN5Mk=L>TY_<qojC@L8nBy&)N
z$8#Yt_=b$4@DGMD@{;}DZoZx4)`mqqlDoUAg$vxrE_>5h@D9z4ZpEtaS&>94Kq7&G
zj#|N-wWVQGOeAS)UgdAl+++60V_!)V#glv^;*a&Z-s6hwzXN#;WUf~U5U&#nyu2i)
z1*PQ=aqK_t*bnx}v<0)5c!vR?qD!z1p!6>efen@x0g}R`>|!a^bd75f2-qhkkPGd9
zLmFE-k6pgAGoOiibb?Y$LYCEp`0$0%g!^-)geFM?4g-KUgAau#lWhG9|F@#VV~CGH
zLDcUcov#j|2rN9Rz?OGbwH=(yK?jvZV^FBJzm4cP=P_{$+KkJw9MV82f_*`0Jp!O9
zH6nOYuUHYXvp_;WbERk|u)hIZm-vASK%fpSEx*Cn>bMq=Z1d+`?YV*J`b@JPYtdJv
z#H@Y9tAP&xweAk^U0AHl%n~Fl)0ZqYC#oYB=S%1MGT_Ms2B;Wh8Rxe8S}o<T=xr-!
z6V*lK6L_w`l*%<_q!IuW@M-v?bSTJPt6;3~5IBgE3j(FAU*287{sCkFfUA4u8rLA^
z(qphCeF6ZXmxX_j0Ho1!5B4TJIWrKxaRNf=`b!<+p1nZ1scI7V6Yv&F#v29yBnNt1
z0HAJ^W`s_A4WZ)o%tbExjQ`Pv0RoS6tjqg~h09!gYC_;)WU&M}O7R><H?>-=SL;U2
zkjh7}CH#O|SGjZMpMi?sWr(c<{O#em|B)U*Iwg9GBu}{vxEx5%RFYOgeZtHA1)c)H
z4u^hmeefYl+t_C|IPWCP`R?7jr|Q`Ph2~C$(dN|wn)ye(!l*FE#NS49E4acQBORKa
z&p{g!bEE-#gxptPx~ldn@dT|;>svVy?PIl1YY#>^aDh2_w{0S39~EqRa17Rm|LPhZ
zBVbtCxps3mmK|^|_DQgOet%ZKxWxJ=h{Kmq7&%wxMs*~ur-*g4bhspv*{65ow<ZK)
z1760|_u3>%@d74Vl2z)bb)V7wKTz8_MVAo#ChuQ-_pFDbmJ6Ut@4*!XwyM3e%*Y08
zgFhepsu<U@>ML4)r(rcp<nM_d8P?Oj(!3L@7Bpe5X*rkQIfY2VKf!$IL!fFdr$>=%
zp%e`tqj~;i9e%GRP-EEW{cl=fAg;t9x!j2a=y>KEHyU&8#NX>tjYXwGr;O%jT)G*~
zxC8#|Yw$}+V1!#MMH`<5VJNj|1lAhltMUKQPXKaOCZdPp>VFk9P`kUkE2x7@0Pr<l
zaNhG_rY-yO5cmq^G!_+ia80g^&N!iz@pqy8T{SR-%%}<R69Qsqbu=76t^P+&p&9)D
zJExElzam_R_zhK-Qpc^J+e=pm|74GVt^a#p^!|U;y?Hp){rf&#_LQYXDH)`YrILLY
zNrlM1OR{7M*@q#rR76TCYuOo$oiO$++1Ig;eVM^vFpTZ@a(8#%pU?fR`+GdU=a1)j
zj$;nTaEzIGzqaeT&hxy^cksjIY}pY4Ly^sEk9aNIh!!}bx<oSYW}r-BpqodIG?@M#
zu{uNoaCFFbo(HOwE7VIu??y?zViREN1o7BJS>rDi#SO8`@^(=khzf4$qcV`?f9C-&
z0Nl3xwVw-Je<31>aznh96t)PUraeqzhcQ^XT7sbjR9`&%{|f(tb4~!Qq@?t2V3~T1
zq0t8JJqRs{r(F?>BBqC7q;d#3=;zy0dRLT)y+6GG2L27Bym>%3&>I7~A?E)D-Qbw(
z5if-^u-`Z|ib~QsgjgOSb*Cfj_Jh2V#jcyJvi@IBFzwH`O-qATsZl^iOOIni4tB%7
ztJ`$ID~lhSn9b?V!Z&lnqG8a`-ykIiTr2CNIR$NX^%Iv)<?)mQWHP3K)D0a-CVgaG
zDow`(bm8%XBzMx&9cPxO@S8IRyt^+sP?Gd^k9&!iqgpMHn}gtJ2Y3(pGNc|WY2V!k
z_=er}&;PdWEB;^`Q~=w6`b7BukZmw5yCw2={p<$ym<tec$hk2DEOCn)^OJ2+<B_eF
z!!~fdmU9KsT?WVWzp^KC&RKehYonH3+qNF$i-2*E%G4RzmouS5yDSJS6ly)d-9Waj
z=a&Dku>6846sYKopee|!=I_Y1zZk)sGqXrM>F`>!4bra1Hht!G_Ieh6sek;zqC6ve
z#gM(dDn#AuvQUkrT+Qf~Z@`q*T-_CXX3>q6WFX&|e`f6Rwc+27$*;2I)tP?ofI+U<
z&J(3ZGXRbOk=33D;5Ep?HY4@yZaAcSyMc4!-(uZGpbZ#1*oMhArz+r^%20CLA9+lv
zvnWmgEA*jwTiXt@+HmXlRWLZAZn0*YOddx10b2$gM#Kc*#t8Fjqn6*{VU$Gbb*V-I
zU>zH}{}<Z~1?mxoJkR@$*`;f>@}6`Ph3g=99^qNmNkibvNB*BVLwNk@3^5O-Tlyo3
zSrpecDD_$R*L>_Y*#wORpuZQ~$=9iev;=KNBa2o_oo@rm^Z(ix!aV>F>EP+nK@vS!
z7I~%!d!Tir^XtFQtLZ<DA-WHYA-Eu;2gVR%e;7kt^-c7icl}pf|ADXU^?c(Xa2Ayi
zVB{;1DI55wHEAXj*ls^5^!4Q8ppIv$%Kw%o3t)HE^3e<hJccNcNHAl+z~~mGJ`?ag
z*?ZI*QdNXpLA<d-!@uR)fKor&2TV{pwSCK9$!&nq6vpYC+F<C1yHnwIwNmk#f*%G8
z*PYBrWxP-N9zcrO04G3CeLb_0M3g!!WF4^!y71q-_TpkkYt6!>v>#WRe{lr0o$!<4
zk|}#TJ$Kb|%3mXlT)gy839Iy@wJx}f2bwm0o+}TGou>XtOz0qS+oHC3^6ZicYMai4
z04c(-)7I<sC`1L3dqV=>BA`*IH3Xac60}fr^lGO5tVud*$iC99Y#}eW7p~K;U;M;w
z9g8Y1L>Uj=6PrGzp&M(kCXq(yfa@TJQ|^Wl25k_Vp8b_R`**kbo=gIH_QKvauDD%#
z+crG#oU~U-toy{v&P0G5^p$%!9e`s6_jj4>%frtW8<n}Pz%KXvCgN1#bPm!aHUOv}
zC^ziH@5!vWGBo}n$FbH~$--?j=7zH{P%nV8T-c(8(R0j~l6xUB5TMqQpewj|gnO~L
zKm<d;WahW!#kvkQN$+i%9U#67DbY{zl&*ZO8!UKiRy_PP*sh@S)<!iYOHZSLo=q0;
z1=!vI8sOM-XAucEZiO(KDzd-|kUOi*3@+(8d(BrX3ur`!JDybTx^`owwiogzi>YX(
z*3{tOax!IB8`%YBn{VTIVE6gDeMx^kahpa|5vtL2S4EHuD$vVJ$dmD62pIXQwQA6g
zG!NRc7p}4m>9g68@=aKyjs*OOI7LB}p3LK}i#DJc!&nhUK^XN!WEBls7vb9^W()V@
zxZ}K5?;L=(i(x?2d_ZCp%|zK)7<;$JNiFu9g%!%viq%ojoGa*OE34U0MsmG40Q=YH
zyBiMB+ww^G(L<%5!>_2y>^c+Qz<%?kW2sMVE4v3^larJA{dLl^KN~5mLrUPrzPW8H
zS%W<~boK-%$z>fMpEz`S_X(eYRe-#kEr2e<Vt{%z><)8+Za#wDLVvE~Ehwm3x-yTl
zi7P6VTe$*xXO<-x$S}LSCXPGt0gG!`RQsqGUWG~0J*Uuas88H^jy^JV1;6HD)9NV|
zSr2wbuE@8=sit?6C!|Z?I8+^`d^Gr!Zl(obUG<8UEc%|(B56AN0Noq_0Pi9Ojwp(@
zuNc_dBUH}Pp7fzSfWf<M;-z7w^L{}jxPsS)DaxPT#=!M30P|J}Elecrp!fGsg88ub
zTH3j-B529BHPouWR|Q(?R?1_H4-yr_iiF1v4uO4w1Pje|CBZLFbsB(~dD}~6SH*V6
zp3{YzaWaTWKwq19ttfac$=yJf;&K}xE8)^w2!qO#QLTuCX$NEIe6n+7OT`B!Ojoi}
zN_Ga$XK!a~qeY;-4wc?s2HXxDwSB-soM_o^`F#G@$&BneS&B-u_UR`WJpkfo=6w>d
ztk2r0J%%n}At}wHpNQNN_AfMl9&{|sB?HAy_HpGn$@cZa)Z)QZO_i~2TqSDp(04gq
zgJu653lH0UKnlIv$f@_xqk7dW*Kbm^QqR;7R8MuoeE_g>;cMM(OJz7nyQ&TbF9rm}
z4`EbaC%1UA3e+W~mr5olaK3~}FaTyS-F+$VQDa1VCFqk|5kq^-G9$7bw!uO1&9Ua&
zOX}@3HnMidmYge|U8<G#P#-8_$TnYP80D!I3t<xttt|GI`}j4!AYIC^WjUn;=;;lb
z*D7lDx6FaB1}~lfA=%DbnQX8meup+NyM;{7$AAv9i)Ji7J1gd<S;VP+lQ8=r8m13t
zc?hyT&oOYv+JK<p8R{@6nQn(0sWqt2D=5$}+oG!l+kbjg3162BEPkf*987#SB~tlo
z75rO1{(7u)%8wpn+LA9k0-~spf$pW4*v$JZJT+nTGxcX%tnuE~-O3IiKe!+Lsyz-c
z-6@6Z{7BV>#xOsU(%cLSt%IRCT{EH_4`j?y9|AjR6pH&F2KRGxCx(i1x2^UmKWRON
zk{9{XE6N$~^>kG9(~Vl+5BIlbW%eI~lcmsMoFk6K&rD)6L|_5%c6k!Gase>~f&G0V
zs<Qsm5V#~Gbss?S4FzAVusVQs1F9s_5muIsZ`g7l!?TJq(v&jo!HHL%i*ZB4&RDLc
zN?@fhOozs60v@MSSVY>?Z(<RZkl1qj688rHYrJO>=ZP!=jiw)BoxASzAw3DA>_#vl
zGeadB*xuHx>wIz~#|Y@Ej;!4IHVV4@M9qxN0<XzPPo>(Qx6-cskaNHDD`qlG4h^|Y
zK_?NllKlxk{_y6G_VW)EU9Hw|gSABxk0cf-4e^%mtBUloWO1Acc9xD=TyRvtv_9nQ
z=_|aSyj9m)UkHy6k^d(C>M9>@o$FN|UCSiWuYDV60(ytD>ug-10+}wEdOc_w=Hpn{
zX(Yxg5NR)DW<a-of5lF6Ofi52yd*zze;4OtN%SvVFoRJUyd&n2DQAL^*Zfu-eZ;1w
zp(y7{xeh~&9t#OBFK10@$5o+=e_;;arEJ}r(1&||W;f1%+GQeyKyMiNn4{RDD9GHV
zyjiYzTu#=@&h$uRzy^&-*K3%370WiUg$N?90B$%ZLRn9@G=-O!Gy;`kf5czreM<`w
zsEZ4Dhf4~TXQxlUKK{YwuD5;d>eZDUr#3OpVjIam^ozSCRwuTN0Q0y~A}&+Y`nb7h
z_-V6yg)tlwh4ksTLHT~(fM)OfJin7=U+R#TOeTt@p>%U17|Hzvj^A5fq<~>Rci1!@
z`+oS>pmhY__ZH#={rCF986hWKfpH+1v8cD<K(@a@2^|KmXQ*@&2h}I%;n1tr-7TI7
zyx!($TTxCG2=Vr8x}o{SLeT?C2xH_#cAqpMVPK6Lo?U8Peg}@SfeQ_536hp3TzA3r
zh~ka&vxV{{jMh9JFM5oS3G?osuv~*n`4b$4_bj6AEZA;_R$g5kDh5_HWqdGb@-~rK
zy;F+zw05~F(SVsD7QVh(=v{8nxQ%mBm<$T0bzF3Tk+ShNzeDjEroFHkz(NiIE33RP
znLW{sm9v<yoc^p5#TkPQSq8<zBayNMT6aJyEgV??prhO|>8Z+LJlQ2R&WVO20-rM!
z&|RYIJsNg6B%z4Dk26(^up5*dri@PM5D^0zPsHY8sJIK};$-e`q`$$y{7bD*-h&(q
z$+m&B8rzk2rqlpM)C}A`2jLA#;%4o27gse{*C{J9E_T1_HXu_5vY`#IvBd&$`mYp3
zB(&19r>zf|<(5`mN}6-0ZcvYSY0(geB@3=zJY(^+!Fq(NKy8KStc&nA9dSB}&2LE7
zTHD%K971KB9L7+TaPRG`eD-63hCxFE_}C{?MeIi<_bMJA`6Se*TMNe*>31n8G!Jr}
z0u6|%$-bxh$_k@TVN6cCn6^TX=1)(`Pd?U*K~(My*6dR9wq%DXttdwcrr$jy?o4WE
zv=crePbU?@Ymn>+-`)cm!kWAM$U%;EB_Of=rqa@!UzhjxV&smSyxDJ5IG>3mj;)~V
zI<Tgo<@O>t7=MZJbETV?8rEUy^}H|B>euICteFao?Y2hiiyj`%f@LQ>&{W9JbYV*}
zD1Nfi@8dshGm%}hmUHudbpv~t<irTR$lJT*i-U1Ax8Sz^x9xAwO}xuNg660iPXJLk
z>WTi`o;Wu1<n}SfYoEI+sK2j|7JR7m!)Kg|O+*VBt)*qoF_CcV=T}^i=ncB$^H2un
zc_aA(y#FIHd~fKsmX4>+IPywAS0)hQ1YeEftIRp^0nQIQDj#pEE7!D^_1rmqX&a?L
zy(^7@95#KK!q|b0W~PL=e_o&KWS0`${xzJPLq*~^a*jM$dfTYFl#&3MfVTpX1RC3`
z!<HAS^#>7Yt#RMvZZBDl_#!`RC1?pr*nUnY%~*?p5k^D=swkLj>BG*PhFadc%WO5k
z0J~DEXY*whWG8jjBaK2vr_K|OiInxyn7a)=<}6#TIlA~-Wc0RMy0eKu9u|dQA+_QY
z(750E_9_u6G4)2C8}l|Dh5P&@2Y$)6Mt|*7(eQI&yTQ6(B^Iyc8&5Q<%|`ll%*U#H
z$%l|#`>xKNaB&3@f0cb2263Hcn)Erpx|&xOH3Tf`YFirNDDAvc#`fN>;mELVK5#_Y
zTS+M=j+6ii%><1dlI}M+W?F@;atA{{w;|!dNYH)vv>eUDNfxc}5f)6MlXEsI9kGFI
zYtTXmkcVUB^;kczw}(j+t-95((8=sL7}l06MP6~VBNl}BT|rqo0cM*cf2?~^+(h6D
z4|h~ymZOly5UP?;0UYas1=0&s%07HpNjS7Q^-eVu+iSD<ln;?GW+adanj7awxJQJo
zI;yh2&O~kU(IVTM-f_;Zqgr--b|zUI19w2L#Cw!++J#|F6yOpWP+C`e;<Dcv0FlTd
zkQneA9lNY~kjN$JD|OEi^bmIhmbw+H%ln#i9s}>BVOof!=o2_m9$2^>PXz8i<f=zR
zs$W+gCAI*C!H^%UT>XrP^9_Y&_IW&?CKy9=?3o3xa_~W)EQW1P`;;6n)XD!f4(6*s
zuglib_1b2D>&05M2e*R`JwjHMt!z+J6H)r5R#6Z8p>?uiu&064a~<!bIm?C&`{Me&
zhP)t@2y6??04+w#Q?C6W#-QM0lh|y`Nm7@9L48$kV70{Wul>e*z&!HXrw(!ZFsY3k
zkRV<1E|LxfLwyVe+W^v;Lc8*ndf`Wn^b(+&RIy3qi9uV#vmUy=h7XKThcH~(?&5~p
zc`kjmJQmHMuQP1{C*BIIdCK=Cv2dDU(7tp&B}Gl&W(<2lVWiY$^4QYacAp2-J1ZQ)
zwBkC~!3M$BXO<rNoMVV>o*lhL0QGTk*-~k<;5+nH>A79dqZugdIB~PPOCAb|O(k$}
zww9vMzGni^*9V_A^DX+Hy!WC#*`CG9uy>xLiU>m~yY`wmcPhNJBrJ_&IZoC~YmRES
zL29s0Al+K&-K9P?R!PLbg*`WHv1cnfKS!5Cn|75eK@fGv>+Hs20t@oK^OcTg4uXJM
zcr4sobt<X-4q|$-7+n<oq_inibmGOP$FwxvZ#v8oB(;jKbA_|GD^e|PM4lC}hzM{g
zX)d6_8blsc{wv2nOmiJ&bNp0f+Gjf)c(%?Q>LucQb2xCUpoPV>&n}OJq`8E}udSpv
z7ZQ<iw2_B*HX*5mH?tBV^ZZpCtw2?C&2_$91QC0@hLGowIGA_MNm7i@zcZIFebamv
zR49B$O`T?T98UKC5gz9=+NF3sG)`YBjR-h;<PH+&f0SZn=Nfhto>4$!3e(elCygIw
zW4r=_Ok}_(qKDa>%iQk#ZlIc^lQAeozRNMjyM=OxN^SJ_ixf+d^_g?Vxj+0A*S%Qq
z9#+y3epab+a=gCO-1L@5iv7pqCL6#Xj{{a)eD*r-jzz$z(o?zqBjav*C9?PXKpLD!
zpJZ82cLw=g+;u_sbj9It=}Swq-YH<o>COzVd9K2wA|o>@_LZ(83wRBu8bkQ<9S*ba
z5o#OEe!~Tro7djjQ?m;M#-jpbLiiEO2Ae)R#>;vniVfTu8kNTr8wT}lij+TmQ;UUE
z91E@gBO`1$ai*hHH7H=(Mo^+$A^0@8rIyad1;K88fyKfP$g8vJdiznfN6)-eR%)<%
z86#{e<*^?NUl3c{7JXRvVpD}=#J?!-6IP$F_mVU2g+TB6`LCA@&%ewEJcN-_*=8}t
z)9tO?4~$(QUSc}JaeWCWcOr+ZR`6b^;Kt_4<Ye*DH4n|{A!;q=O0~+23Lic_LFk%Q
zH;wgr#c5ajXL9Wdzj1FUtx9OgG`S%#-+hgGL`(9S&Wl+W$OKQOi2(2OL@4<xX7WZQ
ziRM*6VI#T6;qeWpeWOlMq0jLLY*AMiw$T2r%|rJsN$`ojGd#C-08;7F%uvPCqihem
zg(UQ9yNtG@BQR3^1pdNxS(%ZU*&Kxjcc`pdJ+e#@1898%BlNivfI&poY4CIWI@@H;
z=_mPi?gkr@a*=ur7?1*%-415bz!NBIQeB486tpp(wShA|O9|^;+69X3F%&%&cBkQ4
zh0p$8QJXlnE_yl81?%%Vbw=zr41=#VkjZ-iwQp8?1c=^d@kbELquXg$hPj20thi+2
zB|8Y8N88tP1tH|VCQ1)LU6coqss$8OJdW}=-C?@CzK_nHCtsB&9kpyqeeNEx2<0lc
zdepQcXn8OrJ|4?f37QNNTye#^h!5|6t9GH+r68YZfwl$`02e+4AWK;wCt!x-sM)-9
zVqe9l?hXS$e7?%~-?2vOQy#1cYw~4k^yI>pNng5-D9*H^h<d8G-LlIw2RDwa$16gW
zaq<67!F<*|>;=TKc@eK`0NsFtl=4*R$S}jLqG@MgFzEV<D>|c9ey_jrf6+_KH<Cih
zu~Aw;Zy$t%45tEW|1#hmNnlcv2Y@*G|960Rm(q~Ck$95M|Bc!{;D_4294Ia37%=eB
z$kr8Dz|JTdyK~t&`_DFrN@Nw#GTVZ*pcl$Uv@dCk7O=cm*p?{p*Ji1zA)jfDKC_=S
zy)WZAZrSmZsr;bz56JxLGvGx!H#Ux>bq*!jb7sZOZl4gvL_R_B|FN&fP-k?VT7?$d
zBygF1C);Dhx}!wwpQuW$YyR`&fclPUKTGIQ<C_4tl%G5bZ#PL(3lymYbZEod6@Kn?
ztA)M2-tn&y72XSnk@YLCi*Tutl>fz>8}#CMrwssVnIYQ-^bm%E$`UkIbZmQA>-dmw
zL&mms0VA7W_HX*2siSq|ScV+96<pR>fz1<4O*Dardi%HHeI>&OKrHAAL})_*Y_f~C
zEBa&v0)LZFS+{ET`kbot)*~Bq1+vfv)mG|;dy;tT^<B4@+oi0Y04^Q?V`YoYDvmqA
ztA&A2Q4$)!WA;JJt{+=J^0TLR-#aLCH|Ou};%b0;-VW#w6M=Mo5J>4w4uFG&<ytyb
zH#3%>r-&|w90FUrFEO9=Zekw?TW#W;tn|E6GUhksLcpQX2Z*tOWvq+s!4U)?n||On
z8e5=Kke`D;kQ@VGE9L-MEb7y@8DQC4rraJv?^!&jq-#5t?t_hmZ44B(3J>)klmz=D
zE&%*7-!szf^`Wz%nE6SXS{t%XElnSEPww$jPZe4q&(O^XDH@NLxAkft{!8hA%U>@1
z(HgVqLKaBJ@`UM0$(I8eAHSx|-sYqV_A{okeLlgPdQN6%Szcn?|Kvi1#=TrHly$;r
zFDD?h)i1T#0p3v~Zt;sbwX_GC;2|KjwE=jpYS(NKi+4@~#It3lJwCqY@hm`?ia=Fx
zMI&{#6F<M7W9+>(T?Ax@`Ug1mN&`##+T_o#Pp>;jzGlz7D{<@OIbix_VFFu!Pjg=M
zTE&5J{b<oB)TUeI(SdGs$f;dwa`!o{^yb)Iw6<1T^mX&QUfCc)VK+Y1;ZzBr^1d(f
zlp1dk*KPWEvHiJ;NRaIH0f%ad*%&8f!nLl-ZvZ$xxve>ie!fEXlLo9hagysEC6;<r
zOY#vamjue}*}r5!w}EWM0##d5!;9zmKlbK>mq)FHBlosPfcg#)BF0|Qt^Pj5`BZ`S
zto_=)3@tcg-*$1rnhzve$i{+Ba`_n`A|Bt_2hOnFfRA}KHKf60R}enGe+rXgMU)B9
z;wxqRe3mFO;;gYF^U8Y^<kS{GxVS9;mkVJP?w0I3hBca60P(Tkv+6#o!<gN4gh&BQ
z1Wn@0&#0*P+gI)`bgRm|&L4jlXyTdy1y&^4Hbe`v(z&5m;BEjf*P}F7z)%kX6wneZ
z^Oq;D^yut+9~6vPz}|1A2eadOZP)OpA&_kA(F3Z&EHx6j(ot_|N^J2!k^!oM@M(j3
zN~)Z&Y+^U~v-`tlFYDTcgR|@z*%}%R+@kAgC6}u%rd_?5xStJ2^EaF~1CGY}DM~<)
z{O+vj=;yPWdzCa9-8$J?6vr6VvU2vo#(F)wSco!qZ2l|wj1jJMlsKAoi=6GAJ|JH}
zcSilCBPJfx?~~GjE_sRWoM74mU6WY+sRb<4TTs3F0@K4m4&{&Z4So2GIkY`-A6KfY
zR{Uh7L@;5`$D=z%#mv)XUy4!nFW#7!-}fQN6dV-yt<>lf_g6N6DC~gQ*f+~|^1|Lg
z5<Sb}C%=RexADBWZZ%bZ)c5xv>};+GyDb?GnMWFNGl0Ba*|1(&ph_C3>Xp#|k^X2=
zs-s=7gt^O;^+<oRK-_$;<4elEJiKu2FTGn;9``ld{+!LeH9Lh}pK0e#;>uT-QR7~G
zfiTjd3u`PNE8!MOIMrplof-$_{-m2~uOtl!rWE_z*0+2B;58u@rHAl5$G22TxhwRu
zO!SQc%DtRyH6uD;I0S^jR>EF@ZOPP#4qArvU@uw8z$!4#3+vJ;azEOptKOdJ$h^#u
z#b%=SxIf3#wofPCMPmSSde`2+Vs#|XytySk1Cc3c-O~sz>XAn3J)=2t-|zKbX#P6s
zqQFLlybppvx!N2M7@I7NM=37MqA!e*zh>vWN`l1hTDO2|^0Wu7=-44}EVNJX?tr=k
zSUy-y)V(Y!*@v`99;f^hGyw@BP}))VX-U3OZTCa%_rs0sMpa?G4W#ac9<la-Rt*cA
zhdosMu}{Iof!3ymPuS9G-O?Qy&)LHeh4sP}_I-cuE+rEGLtV)kr*1^)(jO<AXKnSn
z8_w+~m`p|TisXWNGBuZ<AcGniS&|4jSyEuen#IoA5TQQ5<%z3Ev{2I$2hJmIU<fz7
z)ym=T))oV=Y%aV4?5!<M4sPLRqtU(ki1dntEc4k@xvDE=%*J}x$}MP~TUPci$KQsV
z;`KuS*pFN2-7LO^Y+QKX^5)QyKOeI6C%Nt?_&YuVrlVJlj04Il3(J{<D%Y)h(oD}_
z98X~P2kzGoeaHc7>$}t6-?#3`ZVu7S)^F|;37<d3uw0ZS`SCb%t12ZOeY{tQF5Jkh
zCGj53I#gD-`fxSGML+P+bID^K=LfU#*Df7C!Fu?_Z9@_%&kaGxx!jl7rI9l8&IASZ
z<hu-b76I(1hEQf6v={z$0f>qIHNGNyQ9?E$ihVDRvu7Hq$ke6EK-bbj&I#SsFR)^J
zArXcuF-^Yv{_TqwRA&XP-mDD!G46v3Puw;w(A!<5%xi14EA2k}JD<tdA}uxpz`smh
z;5FIpXMaB4lKbZ5T$@KB;s;t7e011sY4$?(^B%oCqCna}sWY=!LdoK###+w4(7Ly~
z-D-T3==P~Cc=zR)R#+vDzJ0Ibi~M!Kf#NBoAk<Y8c*5tl=7^tf&gw|zpT<S!JHlNj
zpVXk?!LaNIo$55fUZZ$eUOy<0JU7TXWfKb>w~^2|7!g+AI`)oar8Ctj=73uf;=EyX
zo{BJ3Z0{!e7&wcNGsS%|`TBHv!EV``MeJ!3GUV9a^OyUlGR`pWO^SG|J_?eS526*S
zk&$d%-mWxj2)&hKQsMO#$+9O^<--_s?Cb@Aw?zWRB+6SS+b|q}y#w3)@_$Yon7-<J
z52~IWwh+*Hu>lTX{>bN*;c@O0M=q;<em2yMw>Tfe`9LLFSculC--(Kje9Zp~#SKVw
zE5`WNat=ZV5tpf(D|dmNU8Q()M=A|}{l^?1O!IjXw}HBFAJ)uCItqA6=yiX0s*Qes
z3fKesHPxH3?{_?EmCx=L(CqS4s%N1zhgw*@e=N$2M|{yf`$i5A1W+ZAC^=q5Dkj^T
zANb8~MPkcb7o%PVNAc)f3DU{Vish#h7O(Y@74ohq95Jc@>|Q-P3yJi9PBGJA_o7Mr
zbV-lZ+fjm#%PY!D>c?@#&5>6<cRX=muUZJ`m6OlU50CCh&8^oAg#S5#>Y~1hoCz1N
zo4A*A4ZEykwAlOLZspK!_#CaHF*$^4Y0hnP?g)FI{0qhCSG#k;E4Mo-<Oc>hjp1gN
zKPL3iokNI6lQJ3ZFAhCVg@L;?OoJ}155Th|O8n2u{CgAr*p0F|Czcg5>8iiU`3H?<
zUnqNp=k7^t#qc54Zy!Ic_|2U;r~>+#PWhXs#u()v+gJ7#$2Azyc?<B#3&)mmis%a1
z>j(CTM}a?A;m?KsW5uh}9|m9ewhlieJu0yHKEku$hL_G^;|41|B&Lu~y{Eco+j!RE
z?jP&o&C??fYKMU7OEWlLR2rH6TO7|oIj7Yp-oN|n==hH(Nf$}jxKreFbi$brv4RyJ
z)R>)sEE<}a>8~AnaDK2eWfafdV&lV?dNHS5`;YNCOduP(W0G|HxKj!4+vy*F`sdHv
zVq~^NDEAQ>8X=uy_n9Z8<c4IebmWc6J(7xUQJNZWf1wGY-b~Z6_ev7nKVIT6?zexh
zO<?=xGeQfetv7R>=ZwydbZpE&e&eNJ65Cu`U%|4D3RF%I=BLUnrA_g_`fax94(lkH
z`VGV4S9t9eX>svE=`Z!kisW^k5o}d(#xTdhK+Wd4RLDjOsmx!8%I}_>r%Lksm|ar}
zt+cT^zh0tq9|G&`pq$h!&<TSU*!ZZpNHhO^eEj#s{r#3>w1+44=)N%fiA#>LRmne6
z%y0p>(L6uZ$#Qux9E=QdE<7R3C3C~<$1MIloc}td|9;{S^z5b4^Vg4hYat}%Pk7;S
z5~b{P&#CrhqTkT*vv_=j4zquAXY}`6>+~K(39df>^^*Ggn^oOoWw_~Fml?!}h+D((
zf$vDMV*Cx-vulTiPe^>nn1-G5LsG9Z!kr%b^mP9Hf4{lXC3>p+{3G0riEWt22*`%3
zDY`FInu|T)0pg)FrXbUa$#);^?RKyA{LeV{AB*w7_Z5}DtRZSyh`#r}_BdEMJ>#-x
zVK`zj3&%4NsrqWxegkr7k67e=MfN{J)4^H%n@5R!mF=~oY>>cH6J>$ld^f>C@Xad;
zV-BvDdjWf%es(>lEq%B3<>rmQPu9Q3`#-1R0Vh4l;e+J_DW#Z@P?nl!D>pFfOr&wq
zb~Kj4@<$fgyb@;EQepqsMa6oU3b0~#yaB~7Y6%1@#TSiAogFunT4+HlR3zZ3ngC69
zv0V}$Qk$-wZFm{{<vr*h?*0-N5TQ`Tg{Pkb3rIIe2T8raT>*DM>}q-`O0Cl4O}Px{
zT8`wu+D`HNJG%ekI+j_EoELX)d@(HES^?XhBA|UDfi2bJ_jj}^ozs*jY5)aqS%3l*
z$?bbFqHKD3k8%+Yz<qbFgK+g~-Sxs{fs=mAf}44AkAiNbDaH!f(%giu-S1?+Ov``?
ze<+D@=KbF0A*J~JW-FZIHxqIYVs4WFKYHhnOCUvm2dv?mK@l;l#=;c<Oy-&ann_+G
zRlfW9;)6@{2@{h3&Tw$G*tW|QW+8=;3&=k9fZJiNYx2>BmGg5AVW3?49?C4y@(zCD
z(%p}gw0+Yt(lCA6^P;TaO^YLV^}66Fv%MX>su)N?9`HhJ{eyy(d`ZX`y5l6=?zP29
z*?f1;373XJn<B58WI7E|Ui%qhZ^(_+_cFbeHiO3NZ0oF<oH%jrq~Fzwcf;k5N?pmS
zOlZ@m>s>-(1%x!iQU|@7qf;Le%&EWGgsPyQywgx@zl{-0PnOLse`*piVH~zUIjk^{
z>m45>=6$b*-KmLG==<&Z7B^2R?*=0B>4aK@V?v|GHD&G|UhH~*<sMN+uhKR@hPYVp
zh_0FY($ZD#ttA=)bjQ~yXu2Z~eXO#)$Vms5mw+<sbgcazZ#ye(R%SV$^x&nJ`fByV
zm2>TF|26kxJcr!}D}f9r&kbiR<}?%1NzS90#tK-IcNY|1i7IdJ641?aor&hNZLx1<
ze7w^QinA9+kwaA2fTL%GVf>WDOoQTkS4=8+(|iE$odoh0M+^+)Hg6A;QZxc_)HLX0
z`~b4DAiTlRxnl2KsF({T!ap$ZZtlZxQ@|fF{J^%itQB|&0{^D`)MHG-%Air&COh2?
zH@XTSk7jUR9By!Hig18U+<nij)l!;E0SEAeWePe@$}>sri(FTV3X@aXp3P#j*Te~`
z`}XcH8tJ1PPXZro=&()f=tUK_x<r<GvnxFYct*<Zm6x7kahCDIc2TxNMXhxKHFU$E
zzpaJNd?1g1zjGwV^ttlKYd0W(qx=fuj|VkjW5`~j{OyDnMay%3`Z2Z+(70%{T&e;D
zT`hFX6+4@3dIeVDH*el#y!DYO6G-4LhKGl@Y2+#Y2)lArhLUb~KD6pz;-rfW57E1R
zJ3KF7s<S>6VGWhbHT|ZVw;P0fy4OSAWWZ%;Eu48FKxxE7cj57ZDthtFS^3%Kaps1L
zz5D8S!l}uVYol9}HIqvMEO*Lewid<myuMq1U29<Y+Q1<!vtj5m-+>57s+3q_d?O*U
z@b2>S*~SVL%2qV}afQ{}Ln6_Q?5`mk1&=(3cEUb1?(i#3d-agtiR5^#nc-7efI}Hx
zSZX!HO<u|OYO_8|7!(|;M2RdIaZ4I&6TN!$@}^7i)EUUmw=ehbSLeIk(`=0jo7H)`
zK2J_|*{vzjx@1$^oX(1L6Ay_5Y3@)ot|{g|@gA1<J&R|R@$40WwdCB@*33fMR;@U1
zwZK+b?Uy#K@!2fOsjS)2$nJ)RF_Z<Wkp%JEiD$6Zopzv>J-_ALFBh~?Gfn+{$O)>X
zd-GlpbhgH2h%~l3i`cZ}QYk7ZgxN`Q_L%hu5<mT4@rRY4Y6k!ix6*tjUUG&=Q(BG!
zH0dU&o1M16V!UWjWIIzpp9KIDj@L{g!lleaKEo2V&u8WOgKligzhJJb^a0wV5DqHj
zaR{DIzu+2eRZ3z|7$7CJMqvaaaOVxTM?hrw#4}qj{}#7Sw(U&7OzESh6CME6ng)2(
zwHgTuxuCkj7J!OoGSMB&nE`5s;SeeBof2>>A<ZRlCpGq-*~ai%_jT-@?X`LK14y9&
zs1PM>H;Gt8tIPOd#W09e0aN$I3lAi*EAdYlMjVY_EYhRyQ`SZvHfNaZWC;|X68a!T
zOr*nTwt%L_XDl*f1GLp%fLomjI-yj}!@v2(UpGuh_0x5QQs?;#3_SJjuV|RXHMKK!
zO}$wS`F4S{k%XT`CPc`(C&#VYkkN9t-F;=^8+r8Ysw%tXv1-59?0_?~Vre*b5Rf<D
zRS~D7&G(DspKgW0-=?ZP@kr29X^N40r=wH~!-Ly@*(Jw_d+B#2sj>$w1xGYQ_bpr7
z-d$XSx5|H2YW03PIm1Uu7F{vQvCG-8b9}C2O!K4Yvc@L~j8f3x0DI+|8~L8MTPd{8
zV`7h1+U{#XrPhn&*F$j|cT;i1riGEokY!xQoThu_EN9-ME|HBv9%0q>02bbN!LwJI
zpIshVT+hC4c`xSO6V+paK3A=_SDvTZ%B_07Wz(QY*DNd7E>o_IB4#PGlvj<qc5`_7
zi0mth<;vVmu?2vU+k4*<8RB$UYqWpgMtsHSWsSg=@KKfu>#WfC@%&G{dA~qnD`GYa
zB{y&Dg~iQm4n2^=sWR^gSM~EmW`A$6Zwt}LG~sts0k4}B;T^c(Bx887RYK-@f<g37
z->|Nnl(<hnEJM>XBVmfFeaV%#;%XcC+kWZf3uP8*)zQtg;GtZrk1`u@@KTJ-zQb2d
zuLbXPUHJJ|g8!Ae+!iER_Sy&QntA2`0DOIt4}<N6Ti$ecFEyJ)fvkRLTN`0)^gXf?
zzaPP8Q1p?;j_qTu6EnpZCZ<|wnXerXy_o~CURSyX=lozH{1mTlhqts1h4H$!4Jtc!
z7{vEgussI9K?`cJkno#h40JZV8SkfBqfs|Ep56LXKQl#E2C&sBQ1%oBuY<zvg#U3r
z=?tb((A%w+BW*}0M}31c<r4EjMtg(#LRl}nv4ShZMDE35cZLO*myFMs#pc3DQ#{rJ
zp3ym;3o63)Cn>Mg`r+9x(nt=Qg8L%AUl=gkb0Pxh<`YUgQ^u?R(^(RkxL05EfKTNo
z&d1tcAiGs$h>8+{Oj6!h6ER0r{Q5yGd(%&L%Wb=nqrw~O5Or4ghI0$*d6N6qN7T;w
zb9@2$obAnU;m)&iX}x{kUpsliOt2p#BI3m#JpmJjs<d7bPai3W()3>QE*1@C5ob_J
zL$$@1i%Hze^=^tl6nbVl&!@tZCdXzU_S$?)Mk7S2*7d`j*UQ&ecb<JX5r<xRf7d47
zUV3}<Mp|)E>$zOD>yOqJKJ9;_<jIs@*pe>``@TS^eAD%Qr1ESIY;j3f4tX!fx=%d4
z8`B0)(zjPZUEOQacW(5lv`T#R-8D=;_O$E3=*1ETVwkQB`{3SC#mVbm_MN|S25&ov
z%6NU%D{HtLIWX$5Svkk3_)7P65w-uh!6IleoC8l7Xn1aMCy6g6Ok#-8eZx&9&vlRE
zE4@pnoy56~>>*syZdH-V<-W4yT8jTzSib%j9q=<M)g0MOB2P|<j>)n6vt<e$VBjBu
z&s@C=yegCjMkwVvWryTjJZ=thX{3ZWJ_<#&p(<dWlX_t#>)m#=-?EPla+A5ZZ<w)<
z01uStR;OHVI9p8+^?F+SJI=69$Z-<G0B8^URQr7cE_?r#rdWyMOk<?JIxxZ})+8F!
z;6c98Z0pC=l*an%(j9g1zD#r)Y{nW?i}Vww+=I0OEf`0f;Vlz}xo|~KR!QILckGhP
zO#Bc1douO9>)dO2xL?eYl{wG9^(ZAfZbTz-eeyk>TOiAcI)~NzWqCm$yr?BDlbU>g
zR@JXU#3_&N;7q$n=4&Lg6nv@2Y!qBMHQBUVCF9tNU^jZJC7J3-7~1~K4m~303Pd%c
z<($vJCVYtJ9Lg+%mp7-UKqAP{QDP2FQAdV|`(g@2Nkz2==m9gdo#h#tR;BWVgub#2
zDVe3ndxb;~)PMrw&aTDRwDoLEk=_2M{ijRzvpcM!UWM)TyelqgF`GhnrRQZDW>?T{
z8?X@(JD;isf`qjZ*XY!j@c%4=WFMZCEq8VAl7IIcLfLt4bc5;)DWzFIK&zEs<p{(b
zyC5Pc?f=39G%1Aizy3P@l6HL5;Q0$+EbK5zjs{qfZY{kZW$EO^w_ugqObb~@IL+KQ
zuu*0-d7845&P%DKsTgF3a3^J_LQEC_@BComkMAf|x%Xi&J36suvVS|=X&m6nuy$YD
z7Xt8}+54$XJr}|_mANsAbi{<VcnTa5Ad>Cw-DY@l$(1f_nd4;O)_7hvo$3cQ+;<15
z7j6M4xt^jYBi6znI-Y{Mp;d!BqM9Ubhmo?~Tat@Wz#?P~)7xCY77BZ4pdQ1Xi(pG`
zZTCFw<tE998;Hvabxg|YDfTWi5J#=>#zBU?>cs2VD&3l|s%Kjq2`ZK4*~G?;RCo;W
zy?R&VASX&veOJe64cuhs^s3eVhuSBRuJ!{YZ}%XC=!!UT_gmgFlY=KE<O7}6=k{(F
zJ0+UpN=a7<GW_=_+L-YSw2{1~pJL#P)6KKl-*b0EAzXtmeDF*zKI*|&x^c6+T&ZF8
z?r2drE+b?~M5bZS*Fob7*ZEQ}q0W^>2G2yk?i?lNlXBnnEn9KA`8pf>&W-x!?Xy?o
zbRZe~&ycpQ5t;OOi<ZwExB=#CnTw5;*D}9O5ytc?ZFbx99<*GaHBE_Ow-=r#-tdgH
z(--@?FDYj2=~?yO{QIZQg_Bbmd~BFCn!ENhcVD5&?>N%hXTOJ)b5?oINWo?2n><f*
zxz%jDEXR4YbE`pD<H*0qE_*ZYm0GTB8MJJ}SF$+EQRCozHb#+WX-syQ0j@Yds)_9Z
z_Ez3f8$~OfsTn<#VwA`NTMHi`JsF2vzDww%SAs;>TyQQD8l<deKSg)JTQ;Ua{&1mv
z#n+Q>HL+eQ$15Sw%cH`d$tis4dF2(HlQ3F{3q@K<s7tAN>rST^I!(4SERk&tRB}?@
zj0Y@V{s2jZ|E6zEea?$!f6_QYA0xg*J7Q$_nJ<I!<xU-o4i=dOcg92Vwq6UTU#HsT
zEH67e?nw)8nk1D8aUUT^^v{u!d752#v>dGGbM{irTFmw1RLgOfNP2F@UDw6wVczsS
zX&NJJF0l*;Z#|*h8=_yWeDiE?WU}2;JIC33pltq`l0T`XYotC6ywp~H`iqoevV3xX
z+!?D{3xr85@swV%@b+%Ixq9Wml_5{%IWE;=j~4T2?IQSQ)cFBV!{7};or?3TO{H$k
zkiH?N{npG~>%?PL8`(~Umqix03JT^&dcey!9!qNqUl~YI2y&j=L0$3*_o8*_t1<D}
zjW4*;t(OoQm#ZD^g*RSLhM{M2F<A`e+#lXZw;#*b{^W(}`EuRCnyx8MVkT@`mw7L%
z#AEBj5vQqP<Nf4@WbE>p7&!CyhUnOcK69gnK%Cf;`DNyY`l|MIi7OhEJ~P)isi$q;
zztuKkYRD+omfX=bA6V<9ovgOcQmj~vR+%1ekn)5WRXBir)-eIE*7Rt|knqV>_3o`9
zH(`3--2Hp2v$$y4F{TikF{z^!W%Zu*U?Y<G*?-#+17=3jB>X(L7(bm8vKHOhKQ)-r
zOMjh$$Wc@MfL*^=>9}ycH5DCckm32|ng(AkNdL)`vmUE=+V9EseRYtwy&n8=tF2RN
z?9?%SW~N$wK7g6%@2GlYZmmu?Ta0LBXgYpWDm0lM>u8iqIG!`V<o2*tKEgLAJ22XB
zS;TrU5VCpQlvmxo2Ycqc%STE-sa4;nW`OOscXbU^qpP)HDYWi=OG-)mQAd24MX)Y8
z589=upfK>wRiJU66cPX6ovz_k-mcTNM?i!C_l~WmM0nYHDgA*I`JAA-N{?6T>^(;v
z5%Q)GRk`f0>HU3$juI>BK^>?U++skbX{XkyUiuD+P`@80Cj}if;8w>J`AoI3DlKiX
z@$p?k4SYZdy`^N~VS?xC*WPsm=-67<o4&VVa5JxswfU~^%{a-~`)LjRn04;v?yL3Q
zjB4{utE+|xj=71>C^z_3!iUh1-q~c+EGh7>^e0wj=0&pdBhqI!ixly3jz`xSO}26=
zA62D}TuitPIn|0jF>O7}32s}-bq}OQp0MRSLGP@%SfkTJ6m5K-A`z%t9;Y$<!U+z>
zXY(JviAd9}+Y{0KqP}H5=ZBg+h2e+L-4Lg>=X3u|@?34N2VXed+GM0MFd4M?t&uGr
zd8L<0>%+0LUD4Sdwv{5#5FD3kVfLaU*Et?3V`HKU?&0i*D=PZwn>WQg-1PRJ9mh<T
zQ@Q>p)<$JbLMOfXc|}vPpUKJ}^eF|fwgmT%IRw*a0aD1OW&nt%t3)Rbtic9bLjq1N
zA235FuS%|P0va&vIId$Lm?Q?4YtP~D-OI=i@~|$BTT(G0gvB9FxOUd{ZEJ6!2{3NK
z7@hIQRdakTiSxkEd=jB^$Oanno){K74l5AA{HyPqGS^5bE4W7V@<3bwz#9PT!J68k
z%3WxCwwiO`*M&nifh$XrTmZGjE<p7K_%m2z%z_@R=@r?25_~e;Uw-a6=VQ=g;8^y^
zR&pCa^WOm+LSDuXSN!lq*_8Q3&}sJ(3d!S6)_~aIxF_wsY;};7j;WGpVKv|6^(uXD
zE8Kp_m#AXW4k>2r$n%sRC=o15bsCj3?fP7MGI!>Y!ZF{Mu!rSn{FzpsbUF2bo6X16
zGw$Y!N;SVX!O@w#_iR4(rWL*L#;M`z?TQQItM0)V_34+?gWt@=tve6tRZegkl*Dq~
zS+CT5iyM`Mh!hsy({3u-T8x36e1s*GUBvY3HQAkf)~tn8rD$f3{^<p9eW=dTKC{7-
z+0G`5t${WsVoqlN?J~*NB)Qh7qsQJ$k~=j=yf%AufFVIvEn8Ev6`D_lXr!T<aBww4
zX<h!C*@mSYI=0c%GevfRM~|ZoJd-+W{Ydw-v1paiP?c!uEa!8BZRbT0=(o;ihl7qj
z6`I}cz1zHN^KkD;M`gR=x|0s7yjj3+vfZHbt+-uU*^?_+_TZU!#nOxBgE^*lx96BG
zX(LHvxLIrr<sH)GgERz!{|mZ$lST$)%;qzSNk?~7qJYvVA8~0-5`KfRJzl2L3zYgC
zJubZ&S}JMhMQ5znXxzu-w>_uA87aBl`)dWfzrA9p4@Zf|i+Idsyf89BLS2HEz+JJ*
zcR&g5M=yQAn~j&{5;**K{jcxDQ}C~VzKM(NQiPZ^lyvry($xAA)ik_gT*;AP^C8`J
z76z=#Nxfs;;<K04e0F-yUZxLkSPBSZ!t#!qoyTZqHuzX)857&^913Su<5;WAoOH@*
zp0Q*fu=xG!qWhrRtTm9@-I|Qfb4OM#gi!FLE+LBFEYNnaplKmH#A6(3lBF-iPOSCx
zuJ$A6*a<ae7ta1h+X~7&=l*oPp_A;>aO;;hgdAt5q?8ORUh;chL+2ZaJZYK~(`V!z
z5C3}6B-g=XCRx1xT|bldcF{tl7!G!sllErQ)?{UL>*FB41$Hf4IueqB9hY{C*LqgM
zWU%qY(_I<c`Mx1sV|_CS&(jX9epWZiE%`-)&-=|OZR6BE+TGjz!ep1TKFU~@TUINw
zZfdv03p98JQk|jNCNXL=m}PRGtj#?GeF(<VKI)-%#PRo}o*EDH`|GY-MF3%ZI0-p*
z|EP288{JfX+B=-8ae{_5H8tfk@2rmAr8vnVb^KEJR?Vc#CAWc!&--a8$y;(EI-QX9
z<ze+|=5_iJ)i`O+ts19++Of}c{vLJ>lH#{!H@=b5;4cQU4b$9ocDo?y9X{TSU~?+h
zBV}YQI^`{z72O6E5WY-Yj&xF2yVvgok_O)Pq>p?bae8vE8pKhgh0Tp~-$>t)Alqk`
z8>BR(bp_>)bxtT&u@HE@c^=tYl7IoY*;u_5eSFh=G{34+v5jX+%8BE||NL!pBoQ<W
zc8V^a=Fx7M^YkPv33Uq6x5Ge(+)8u^QbY2vNga{?MGO6$BP*Sw5prz&QYea9vp`Ye
zrh9>bf;-lIm^`AhK|Hls75;YON=^RAyT_tTs<4=$s@h1$Hhj(>0AuyN&&u!LR(l_L
zS+pk=?ZXdQ7d>2#dHi4d<PWC8SN_m=ewhn)CWqC%mtB(fHQ8G~*%yG3%$!VWgjbtE
z0=+R(2y=#Mttp+ufP8We`80+W6KwxMfU`PKd3E`O>M6_lKf0`yTT%u0#%36iIG!`t
zKju4MI}?4Z7QM{$KX?*f#Y0RjK>eEk6w`A#(dO2zTTz=EzQyX<TwhP*JjU=RltTOE
zA2b|BK>c6dD2pmer$X@0XPLJolE|!b13JC!+n*nQjf$1`C@-57a%jWu;f$u^;3@S@
zO3}%~6amCjdkSOI|KKpm1bxdr@OQx$PX@>ODGVv`-lg_$0f4{fH~Qv2#nxrR#ne-)
z7PQB`oXAq={(AQb!$xOdhlu`}+ole0XS1fX4l1u__GBl3f4t7;(KY(i#}~le7LTlK
zkbHXkpGDcv=NDy2(gi7`uF%w!QZF=4s#QZ4x#!sF4x4Nz(%tl=+Tva?gDi%fg8dO2
zWJ!D#WRaNTMI2vLW^Z!EL_8tNUSvZX-=0_Y*!`bVck#_IRg$_rbloc~G*q}ooXqt+
z{ghAy%@yNsForn>Dq?jl#H=UtVdbmM!TP`ED*_(399?t$)V-G7#rr-vP1kl*#=Ov9
zPy9#e|C5HHx=F&pDplwHV&QhL0VFt}DjTwjIUDA!A69`;v1gd)4{J-mAVuu@0kV<=
zKZAO4-m*G9``UsO`~97T(79BI{n?8YlSyBx;{txgE3#guVkBpl6R&e&=v%J?AbOX4
zP7q3Ra9x&#flx>b3vcj>N}y}uo{6UZlS<!w|17ZTPD=;x<$<!%bE)2I6TaR^l%&|N
z*g@H`lefuzjRKq*`g3hxER;I(4rYN4Qk^<Q87ll>$_1(K++Ak(B06vVU<7Y}B2%BZ
zl~3%GdnkSE&L=d7vCuEx^`a_?FpboEKvYD*pQq8T7|RdMU4oBgr?=XTUa5eqg;g}d
zuOZgy7y0jf^Nf9W`H#1F=5r+NW6Z~KJ;777*@Bns1Z`k8Z2Vh90#jZ7KbGhZPV?eL
zUrqYntch~1@&=21>vLrg^A|WS`DZ%(#!|DL6y4W}U+!W5;thB1R&jH1Zpf+YbDgL0
zsTEy+x!XFi^Q#3@{uei0TLwvi5V*f5BF+&X#Jt+T+z)eIM5MQ+n*F(uHzQ@$-FvYN
zHD!<wC*;P{)WWd6L8ltK{|iz7i_~SkLQ<a(k&^&mPo?~`pvF*5tlBLmA{*i_x;jG_
zVOGfULj-ep|9FRk;PTEr?rx{~ukSGBcVG}0m7nN3@y&&FR2BZe@Qt5aiH!4bK9)!L
ztrndp)iM{H^?-REXAWH5x0REw^Rm+j^Gsr-t9Ab`9=pn(%+;>nvdt(P+H}$2IrNh%
zi?B>n+ovARyui~BV~9y9?Z5gk*=4YDjx+OP+3Mk(NNBUXRnU!com_~E&p!5Xm~aH(
z(l3*FGGIEho$hCX_<u0ToAJ+}KAg#)Gnra1oVxdPEgQ8g5~6|I$BF3tCnfyzdG%e8
zg8I?}5f!-$L%-Gw6phtlO+~8>1g55K3W43P2c{nTw+l^j<R(h*fMI6+N}mJXe_iO3
z4h|~m)j`P$eSN3(!|X5FY$|UOHu^3huh-N|m^%o+@>k1TO!xOqOd*kU_Rx^$H$Ez|
zeC!j8{A&TJpFjM1JZ@MxYEcs&|1~m1BYvWytNg()j)dE42lM<;^4R4%H=5u?u!3gT
zwNyQlt}$%5(7wP!KO4>V?4>3Cn83}TXV7Py=2Yjg?>UNJTV&aDZw9Bozl#6G$^_aZ
zB~}Kq&AB-%Cvy58whDNV)OY&P&QR}0n^>(FRI?%rbC~#=qD;@93vfrNiko-a=F&M1
z4l!FnxFe?etsJtl;=bh7Uu{|z5)N+~GFQf%Q1@Q>M?vY0wAIWm=LRX(F_*(62gkz0
z<jJ9n!5+@iQ-6lYJ+{xr>*g5|YwaYqmW6>eM`pnHcf>SgoyCa6fxBh@*rxyWQ+Ac@
z4RwOVO;@283u*Zf?m;+xm?pV<h=K%}&kG`B>Y{j1A6D$+k1%nO?=VCC@xWW;_#~t1
z*!;&_F%m-6k=-JsjH%L_OUybySi+x+<;Q^e-mOY$O}%~rY_iu{bSuo}=P_(y<x!zG
z&aTtXvJGMxvl=An7qakk=ammu%rmmLp;g&5+bvDswFvP#NMpO4pqd+-Otx>2eu*2m
zU(5bm!1bTi*(QRlg(4qwi4Nz^(9h3L=6>EPXpUB+6M(J+EBOq(?reu+RMee6#Sd?i
z$OOsmvA$?tUI=oNBC}uLR8?o(AAc00vClH*$n~pndZtJs{CdPcOXQ)1zlS@jR`Xdg
zv>9#{<~>O1@nUC?CA}z-u3jTeq~ym(c(c({F*S>uxaUAoSa~}4-rt=-Y)2T|p;Q?9
ziL7z^9w*}f_ZUGz!JZg{A+;(-ns~Ewb}UvXv31i!<etg3Kcb=R<V<auv~H&2ZnZ`F
zF`tvXZXwu<KZD=jW8yn@;Q=ADA&;#e-k9w{wZc8c9)K#RUY>)SGtBXa6|sl8+Av}M
zjNo?^Ws%jSY-FM987_$f52ymbaoi`-Ao;72kbOvhEpA;rH!#n)Bvi7_g9<15MyJ!5
z9LgNzx)zj!AgO30Z}(*U{)6xFO}a$?g3Td9HpjolGzN+^`*W86aUh>~_w0x+oiB6X
zDL=_$7s|Af6r(qk%$q@A1zFVY{UFC{Edj1c;(db4Kcqgacc>P0%i3d7LB4qBX~kyD
zMP1>jUXhbvAxgVN!hWoze|*M-QdLSB`uMn(A?glmBfAAMiW<Kh9wZu;dwcvoVnPaY
zjgHK7s`n_1#~(-I8`-YovhHVJA3^X>yjxmmnpEx+IZ477qPEJ~0{?rQe~$d-RkCbj
zBsZvGA^-uk8~K>Tbphx#$Q1ALpQKP!aAz3PdZc*P4#-!kd|Bz(jFB^1A*fTZHz+Z+
zlphDrMP^?kribMi(gAkKH}d0Fn@n|mscP}gXoI+y|I9<)9`(KPoZ=3U)J?jG0oL;k
za6j>o;t&_t2jYBopS`VAl$l@p<nUJ~^U-pT>Vm2Lg1(RLLi_hjX-v#o6ZHZ-7-l=O
zNAdJirsq~E)*H=2UJ;fnQh$Dt!!+m<jdD((18eSofw<X#eC3W?w>!uGI9h!l$&Z1)
zdcWHDBjp|%SB%RU;YT2=+0L3RPD{gL#rSVgT%pu2c0RVB3AW+Qu8s_%6nQfIhDRq`
zl=m@cJ-Pm{jw(o8HK3$#=CLhn!KZ7Yx>R*8hR4*`19eu6$ld(wZZLnRp9l}SMt7Jc
zC^Vm%_>pPXg*M{P<L;$W)wzmGj_qq`OS+plD6Hdnqy42Fx78Tme-77e)?6xH<8ob4
zVP66Q)c0%i-O;2_?wUTJ8@_ejqJ_)U)O58&o~~)UHmLPFl(1wcS0VVgt8NWpQdyDi
z1AM_R0r`@8iG%4^zzejxyU`t<D2)S}r8__;-y-=f_)H|w_zvWm2cH%8-f_RIo%wN>
zjik>Y^&azC;OX?3Ab6S?w2S{A_P+a(>c0O!B%)B!c92v^q)_&#Bng$3tYniS9LLI5
z3Z;~tQRLucW}IV0R$19cjy*cYv5sT+eV%LFpKFx+`v=^=T-P~W*LAM<c)gyl=Xi|6
zZ&Y7K*mh+{lI50$!Y|m1`^vb-NV{IOZcpbw>o62{v(P~WAUn4K@NZrT5<L8Xm6C8x
zuDjX-)QG5jcuf8CG;QpOKE<dCG#jf4Lj9hilG2l=5YIE*HTp6mPpfq~L(xix<0rQ`
zrcpfP4P^HG4)W=9q1~^}HA8+0$PJSvN0p^O)lW7C3@%(xuLY`q?)|YU<jNeN(wt4H
zvRTdNa#n3^&Uwar96hn}{lPxw1lh3OOF<p<*{A*)4w5&~dgxaM)v0*AvqMRQkbg9x
z$i#h`2N5IFEP)DKoS;V}A0vBzEbMkej2@dn3QRt;UFXbsA7O6fT>^CL(Y>rsI2J%z
zz2?<P)5m3=;Pm>=5LfgiUe1WBqlF)wqY)+pf~w}>uA`4rW$o~%_le#P>g)dq#D?Pl
zh>8IHb`_||PVJMtpQ=ZPI8-M61fbjL(t!Fm&!iGx#>(T}XCL014zcl|+p;YTKtPO{
zoRXsFyez+ppaW%fw;$X)w;)AeDgYkN8z7{-jZevoWKo#ikvM?O>C7Atd?~$cEv#d^
zg{HP96`p5hl>2?}wI$NQD2v}QjC~h3m8x2lQVI_e+%6~D|KM9<3RDf(A*w{gL~=?M
z@!PGMqus?O_0Qhpz7)cB#tcR8+llr3q(0KSTbdiO^mTL2RL#z%<PN`=!zB#Cg@t&j
zHq#>Y=byN|98*3<pu5+1d|&HFQvoT)J;jY8XR)KHN{-&ocCZsUgWmuBq=oa=TfL9y
zZ<Fm-A*@oO5kzj-V#hup9n$*lT6gr(D>28wb3US`=Hj&upz{oRcun^y47P>bYck3(
zt$WVTOD*aV(<$ol;w)`!D;_72%SwKM5^^Cv^vrd2F9hjXX{M)*;a|M4*&bM7tAJ)2
zi6Qz;T1^0!#0+ty4|R9D2y)uZ6y8x7NJi;Vv1!u_)!kb%FL%(a^%aiBh3_#$D$GyP
zsoPXI(Fgl)LYzYeonzX0Nb1CXqiyKE5G+DqfNp1%wcgxVAhv;7-Hm?#@w)|A0Ds<h
zczSJs%ZySLKTK(PdAJv6a<y1R?BVgKMs#rDy~(%7V+yWcK}ZU{YYDh``{C;BM6eTX
zfAE!J+tIaqpLRc#bhz-5c_iXeXpiu48ez0;aZlR9b0e4aktUZJzZarr<8C{5KW#}M
z6i(N#lFTfNS!2*|?C1JLZKn=o5$WCx#FzefIwO<v=~1=I{OB&xcRwyK84qiOs(x~k
zf<E?pTcS1py8MoJ9V42dgBGEyhaxmWY4(KtIPrVC@GI(I<As06&N7~+!HSo(7AH?=
zJFG1`mD9`^Z09jz`^qOEP!~kLf#E;h2L6&!(`V|VC0<^Pu8BXYjws%ZUc;)~yHi<f
z^x;nI#J9p0*<`!!eCI4#)rjMwz=Q@)N`kRt2XzkSdGCpg^Tex}bRCZ_*}^^huqqGO
zB;cG7W9650nX)CEkgws=2~cxuNmenXWQW?=De$$UkFjO}DS$3LAX`CZo6}e*yOY2y
z`U8$^{(AcWwp}yTh1_<F6S@gfv|cgAhf_iU1r|w)2>R&S;}op*!xN*DU328FzTJpa
z{O4)m<vOKMIb%Scl-?a-bxm+kFE7kkSo7H~I@N8`F7R^6EIu>h-I|=EWwZn;3%h(r
zKRR%=g@xSU@6RRtgs(NJkvuM8);{L{)n-DlLFr&!%a%r$V>Tug&x8PHCUdpq#_Gqq
zvBk<O6q5AqkBtSAjhRlRHOb{UhdnM(e3mHj_V>kFTRmhwBX6#+Wp^)hOZ<3lU}NBR
z^Ck{uz%n6y+zkEvzEs@ye`ogI=ee^j&&dlhqK?gLi6O(3UiIc!gwAj)%bdGon;s?Q
za;IgxBuIQD-2z>UBj@S?J-B($L_4A9I&#T-Cg?>kpi({%#)ICmo;*k^tN5ig(?CDl
zqVZ0{q?Ik4$7aj(-wiV>vkqi(@;CzZ%2;}-zl}B23)vub;Ny?ufZw8ymR+_{Mv7ua
zx3)S2d0KI&jeCDO#EL<>Crsn%OAep8UZ7*bwKlKHz{53Xa`5WBveeZK=Id-X_iPQ5
z|G2XN^*!p~4{|bKIQ2iyjYdq@+%$|YJDaY8ynW~U8EoElucGYgvn&&m2LT~M6V6co
z@LGEO(v%ONcB)8A_ezgPWh=&g*HBIgenBX4)i*C8pHD|!zdUj3+M(d{o!H!#&Tbbd
zQ5#9R#p)qbGA6=O77<qr`2Yt1h|taHx<9H5gAu~aaikKw{Ypsi9rp3h2k&LnzdU>P
z-{^ntVYXC_1fQ<kyYc+<nw2JjY%)&7>*ZCck)mchZHbT6^n!N_S(m-`Tv?c$1+}+V
z$jND2XdXoXxhitIIUp;AK*}vE(CeXaJ!D)=x0;lu11_>)=INPtUj)+X<-G?Oht#EK
z{IEc7G|ym^@MV)|LdiVw09YLy$S0^QnO&+}tejLqyn&etW<t2h7oY^%wO`A+bv|b%
z6E&}2-Ot0&9w<Q<(=C&+opqnjr^{bZjHFF074?B-EG=x}7n_yoUEIs>TFT9zhhjJs
z8VTC{gzHpbI(OGD-7{8^mnUQ@7FLFYSMu83`Zd2Vt$$v~F8=a7!SR;A*u(6H^-B21
zFIE=zgxeNoze;cu@0|(K?qBIJ2;sS%K6(bbl6t+dsp$p>W_86tcE`bzy`HQKX_N?I
zrCql#6HoJO6;;1=*@xj|ob8ZKek?)8FL7z2f-n0{v-!(w*HPKnTw+&^*#UtckJj}K
z-K5QxU3FpyZbYL`rvI!E=hMhBS5tV53Yu-&0wzC4sG?@~$C?xl9XfOv7?C@zm~H5?
zZsv7qXWUQ$LhBIdM4k3o2T8s+AlPy>?K*!81J8Yj;aLLD)sDpP+}%eq>`Rv34mHO2
zBEQ6+b-Vz%3>B&v0hsJwTX!^KmWmjBXe0-o8oS<Bwdmfgere>%-+6O)7IEfoBA_?E
zCZ1=O$?LxVV|{HFCRR+?xdg$Ech{8npSEN}%OSWSZ8{GJl!d)gY79_kf>ZLkq!<)N
zPIRNU|44leR29#&?>#y2S_Of}yynk6XAi0|-80%;Eihzy5IRzGM=DrLca)(;k!Jq8
zr8lp7G_pmQeR?eBu=?`YR>4=-(j?Lk+pV0=`!U!bav0lf<bKTj=$%nn;q5kjLPb@(
zzhrz|dGMBZICO4G>E)TmeaD9rS-;sZf8RA%bfb{yqKJOJB=Mz==s#{}PoI9*^{je+
z1|KGrG?c9-Xq4He>`8Ff2xj?S>BI{lua7KF-q*)^#_YPV4$A3#ZIi~`hZlTxOxyGY
zJ-eJWB(=v)GqOjkJ?ETbOl&XQU($$BUuuxOaO$_gsqkDc-EIShmd?$qYsDuQ9_jAd
zLqo{ft2o5gA;C9|cWtC4#Z~4VBIFb>(i=*V^!j?j3$!cUcJE0jvl*3Pe(dIRW`=E~
z<&CO^5gYLi0n6Xt-@hPfGXgb4mD|mVP^GYd&QK(It4WhDPiuuzPtghckr12X?IC9e
z2b)<K93C?>Gdtd8qnOLI%feR2OJvP8HSx|BmXuC4*nJby((Sk|HMo`Waw$7oFV7e{
z6$-@&8l`Tr^PJlpO+2CGg3jkFN!!dXdyC3SnoL*J>ryIqUuw0tc=KcE&H_p&a?-}7
zI8EH?RG|Bb?)Hh3OBrbA!pYHh{oZ&NaT5hOjuIXe7vAMEfh1i!eAl)~lJxT7iSAs7
zF;&yyXg!;}v9Lqi)aOn#o@v!%*0DA5A`ZJY+!zky%6cDvyY^{qLc@(?FbkM?pLN#S
z)Gn{7iOs4@W`T~yhHEIEt5vb6W8ctCp+@YDqp$r@#|x@ELuPCH^kyexoXpo2KO}lq
zR}Z}@pK>Mo?=CG3+7{KLB)d;U{|cw9X_{mA6nV~GEc9Bc@~HD#)TOG+`-X#AUv~Fy
ze%F@!NLudon>e4}8?Jx$41aIXtRAK9%x&w^7)>)=8U7M^E$4{8i!6)!0!;Lxk&9Ey
z+^cF}Gky6~490_FeQ>{xfs|tZmngB%J<lHRkr97>K8V|>!!%YpGf!`2%dPcH2z2`>
zE<wBkbxM{x>aOUT5Y)}-r%6W-AF_W{3mYNzOlWZH$y6o8g#?1}bhomIoJx;X@TAP}
z<XMNll!|<vfb|GPvsu+*iReqi)zbF6i4vV#@89z3$tkr>utC&*tDMw2O}wd-J@Vyn
zP|lq^zn#4l`{lNU<i!9dYq#|${ISCi&BZ3obRrcdFMM{Hlc=;NO63Jh6LK%4qijCe
zuY{_0uNVPbMA~mXvbajc(t6JQly<T9W0IWKNT^=gc{lv>6N}*`3H{E`Q=*;I_uF6j
zJ6JYqJ}g;#d5(SS%OkP2C%b3QuG3B4ac|Aa$+lj<arWL=?(O<my(zTDWkjZavjOD+
zy1Jr=Ips&#O;^Xo-28E!%+I~~Ud^KBk6eArqgB%7EJl+&U)mPtO!o@fmn~(5lH-={
z?UQzr20+fIvO|GLcPrXtL6Y8sZ$Zf8zLevL_doy2c!Kx*&goA%>nHSM;=Q=bln#5p
z&P=f3{)T45ObU#QKjf}L^I%M4tKVtZPhtjN9og>fw>Z2?w&+!DecJL&(!e@L&-}$v
z#5`)oO?>T;Tn2#$QmvO*ddFHNb?vZ2Z<wpjt`GGev(m#mEr!nYZqIx8^wVHWMLcJE
zzX8@Du*#^^c`e{uEDx^Qq`{}Ky5WcTvOt>KDG4m0an<?C6@=_$w%hH8?q3~mDtqrK
zlv){@>=GT1Z8Q}dq%>mJxKu*k+h*Zo1Z5ADc8-*n>U)M39b0-7@HxCu<`9SV3&*LE
zZ1;)2t&uD1FC7NtpZj&*!tFVsFMoq#dpt6`3b${oXM?l*2lW!8T+J(-lDz%?4l3j=
zFKk)2O3NAFEo9R^vK8*P=hb26VU>x^$i|6dK1V9tb~~bLcq~h@7yM`Ax->Vd1yGJ#
z-g)7XfVFUDR|xNyVUE%_Gdf0!<fK1!IBaP1b*0e8he~}*nf<mRY#${nU0Zpy*=9wO
zwL^i<+8l85%;{|*?L2KWH7!2jWqF@FhVzQ(hC4Ww51x4KJeQUqcC3e!c#~t~iT-ge
zoNPsc6~24!4JBFU&7IH6RN(e!^GxT=?3XF5M%;GGr}JNmCEfZEA@j!jh_l-bn_C~O
zkdb5E&Dl0Rjd#>_KCJOxP0<o^E6$nr1d2<pz~C~Cs_)BjB*0Rv0zK=82MSfQZHcjN
z@u%#a75478_d|VYo^M+ok(VurD7`5A{ZxXZdtld!9KN8a@AXgT2-KJ$@6PC_`{_R8
z{IsWzuv;b5)stM|i5OI)4cELf7sqUKrpJ9A%bYmn@yIO<-rsp;sc6t)^hl-zVm9=2
zI&ncU^CtEP7bWt0w#Ty!*#Ux7^zqc1I~+|iuHN=b<|%!Q?ANloyUCX6PA+S)GUHCX
zSK;sDvFGoPI;#)oa~OvAE^vmn(Gw<xS*(R3b9#26)dXj|rmTMK!_+2ASbXl<HJW!L
zZhR$Ox@CQ<TbIEW)^(KEVp^_S(z|n<QWlC)?8kQVxV$NvI}%!)m45Wk&e=bEY2L<s
zKorPAGEVGYzTl5kYu-Y$JyB{KKQXuG`nrCor!_RGU)$TY$X=$4FDrS%@a=@dz=2a{
zOOK@xO%0qFL&a_1Uy+_TcE6F!yqI!hEe4G{F)DcQgu1j&#rV1kzq1?e7%S)6QW~Dw
zSHGrgB&ohztevl9_0EA%MchKhnypy5_g><MJKvtYUoAXru$+sZ(2C-fF5c+HT;eu%
zR`t7xiJM{T%iEU4sVH@|K511hnwzyBMzqL!G-VZ#a%R}Eylp{vVZKdjS2}`_<I~P^
zSi$_jJj2n#@KO3ejCS^|9V#zR#-_e3)Y1sFSe)%bn^gu68eB0-u@kadx}o&aE`8O0
zb6V>=?m5p$?gQF)UZnOmFn(-$o^kam(~HNCJ1YCdpT=GIHNlTf!kaCK#Mb#VEk)W7
zFhsi$1Goi+p5EO%xXd13Q!w&(<3u}}$VUBOyqWKs)wqAg-*yT0@}{(h%4`G>ZVcb;
zvKdrmoNo!NmtZEd`&_^b4ew}F$+@yUcdy|2z0Z$)GJK?k;YfPPGCOu}Em`R8TDw^B
zZ9tbxRwloQJFcEU@V@wQPj<JsLq_k^j9>h#Q$HO)|9<{e9x`V2rBg7J>1z`t08ibv
znx=W3EBY1Yko490mMnqUq{rfW@p(q+9PbaQFk)A}o?9ADQCe{1>_lA*$orw;xw7PU
z-E~%hw@E5^E~uQ4Z@=s8`?(<ZPLD?(>E@zlwa1+F+u9R9|Av0FeOZ(}?Q52W@7``n
z)P$0V?(O}TNA=|nRkOxE`>`@^U#l<j;X26q*!{sk{#Wbe_aah39YDqv2MlpUo_t^}
z`e2#J$C5|};xn91BAkKP9Qja5v~j4Y(D$vjtIpBB8ukX|-!zSwSj0HSGNQu|#ghmk
zk>sgS2V0VgN;uCGb_@~&WTwla<|X=pMQT#4ByLx`=#Wf(tjZNG$)m21h9Z=suD_5J
zLfn(8D(v^(Z?>7?FZA+%G{C9D6<#Wz;T~cOjiC}g^@B7%j9N%FHEHnHByst<CJRj1
z#6FsP#X5NZN_|pXMDAt)cFrI_&gNZGS&@i-sP)<fp)vDx)~7<p?X41Lxx&xthyUwz
z1gUXvj+=$q#(;E@!tKE65IWkDszl`j#HLKw$NmYdm+9S-EtPNqwI?|jpC)e>?G(T3
zWbw|9)tIni{l3_|{ijpr|BSB=)6gVkqb+3ooGO!bvJ5`Ca7<++VjqzN29%nr6BJ7p
zK8cOFtK5~5_GhN0S3Osh`sAI!4@>?JcDDbFIDd~s7x&Y?<1SLVt>ar0A~~Lrh+~?$
zsP#Yx<HoqoMm~9^+leKk!%;--2JQJvd!AcJ%Ip|V?sBlm@-MYQpyN3H-AwrFpQxyE
zpZny>NSsbn-Zvm!Co;<JG-jHi(~lsF1kGE*e4u?D*xJux<k5!P-?X1%{k%R|TK8s7
z=dij$_YusKv`hGTt8jNAX`X+!V*m40s2?8i(&UsMuXJLZ*Cru@Ca0rxpm~WDvSEU;
z!#K~EBtxY^?$CQ8oFpVF;@LC#@0UK&Z@g?Sa=&Nn%w5=PkL2j-H(>QG2$5u*68NI@
zSQ!^k-z<I3a}wi(iqtMQ9RFid__xdXdtUpEC+rfg|Ecxj0kk|uQ96JMN_Z+jNP2LR
zZIS0I`aAN=J65{%Nqp$flH$Mp?t`szT(Fw=0&{wfZ9uC=nF)j9=;Nug(W6IwNt&!l
z>cIy{{yxk3`z8GCSIRhHIBXcazi!Kb<SdLNv4fzV<;F4Q1i}DZA4`}PCHF{^Opg6x
zfcGbsU}r!X*gw31_L{>aUJP?2=B(peYBoNP^IR)BZcubR?4$XYS3E%dJh|kzuA685
z;-H+TbV7=n^W44<D8>nqWEjP;b!8lq!RHzY=p%e&E}utEhDtv6H93*X+m`j#dqcW&
z*yF9+_Mg5;l_$dprfVhz9M{kPGJdkTx%q<ekGV!U+<wp~M|9!bK74muUv>Td^-b{2
zg1hC<T_*8-mg?KU|MY=vPm$Qkw^y_s19Z<LgNST+E!{xwcu6Pg!IPorfawtN#Ts<A
z^i^_dN1+HSv6;(}drD@*SaX%h8_1KvQajc_q|ITxU8wdMUoagDvPQ|qN&Jh`(yUqS
zbN+C!Dy=H)N^!V-JNe*Qhst5y7(r+<$i|KXwd2_d1Ibf{N2xS1v2iUXdoSsrnwYaW
zI&0yoM|W+hCURnYU~<jzE$_;;o6?(I=QS~|x#g$Zuni{rm;MFc`s+4)DBt(x#peM`
z#gfBrVZ-ClBzgwSlS|N+tEUm-FtGtx8!uIQ6qvrQVD&LH-CtpjBoT0C0QLQvtg@@6
z)N^h5?fR!ZMyCf{KoWi!<ZHwSc?dsrd{aa6c(l4py-Lf9xmb7H%>>I+t7|deL4}ta
z`ccmT!4;YHLQqG%BiI`N;!ojY)Y&xc3~P%-TdJiu9z>=10H6C57SMiKF`M@1AR7{y
z|9rZ?Z}!f1H`DEAbZm>F?-at6i?xOVEki}G+9`pMf%J~VK-|vT8|W&8g>4SV&^^JB
zc!h81xnVt7VJ_m?O59}@51`#01;Wy)IO?S3v|W=511sV<z!#qb`FS7ao?jgZ^F~6~
zQV-<LP6SO7K)S0O*=7NXQdAYE$2-b|4T=uK+J6b8Jyn1lb2jYjrOmyGTtrs|&miwk
z!^=~JPTpl?EZmw3jJDL~UlfekgC~Wnyth;T6CcnJ?HVlshRxa&Z_t{<gBpyHFgU=5
zfhB5W5t!Ou1T69}h`xyoLp!Pt`VsV2mqd1LVc7F1+DC_Zn(sj>OM=0;)?Mh%x&@J=
z61RKYvy>W9#Caw(^%C#d9~t>wkK`9I;4quFMl{0Js3d4})MTj|odNsuF&4jlI?-Uu
zdO1#7?~omjr7>GV|8MgW>SWI#IxocgZV52VsRKV?;p4{&*j9E`5Zf~Zr-K4zK+(!a
zckYa^^x&YVUwU~o4O{n2yFBP<8L-go(!GBD`S%>-a@xVCUVUXWT?O}&wjDg9;XL)t
zYPk<@0jhQml_<vX#o0c200S_RrUO_(U&P7s+73g16q^!35&@DLxQ2HUG?RZPRQ}^k
z1L=XJc)Mp|EqseNgDT+Q&AkDW#mg7>GIp?y$8O(m^EpE32_y8P9eHO*Ys0IjEGNIo
zC47eX^#X+D-T2xYqb1Z~n#ZSW1ST8x2WZ(=4fcIpEZbEIW1`uyq|m4nFi{d=m7tE_
z0(pi%zjQfvbkt`i{R7i@fo{;GHPM81hY@bHIUxJdtUwK#g3bTFH&(Sf@5}EfhCk!x
zKT;IPPtFJ{xoCY3<MG`wLYe5|h1se^8*IB>enC{C9lt(r+-qvr-Di=q=fq96$ARxU
z3i%HYFtmr9nV;J1GJ5T$piYC|jKWP%zd7%{p|4i?E<L|HB>=K;VL-g$owDJryNmb%
zmLu-?PVLdHBdu>gq-47_*dP*%s$MC_?kAF)nj{v#CS3W<Hl@|4Z0PTv(NehKsV48h
z2fTgy!51ve2l}f`;PJf#3*0C+k?CwMIZy2K69zXPK?56~wIm?jWfHU!CuXC4YWD$*
zqJ=-Q)VzLwOWa;A<go{20<Z=vGXocb)eHwkrSHBHG4Xlm9a`_m<+*6G%akj+Rk9oA
z)@Ed4o2XeGJ44Dnkq3KZuygl3JG*i$%phbnTsz$DAP_XmHWd5GxwXIQH5KyYgg2r`
z%`4!@@<yD2sJ#_^d$+CrW3Bx4>qVN)+zv|V4G@{Xfl}ZF8xPR#c<kbF?wsFH-3!$S
zVWSg_TuFE<;4IvRcy2z|6|nulrDUOe5AcUczW(lNRZa;^*v)U=>R%a&wm)pq5c5n(
zU;KM-Y3U5H@fn|LOp5Q8$Kww)sNy>B;Gn{SCy&qg{rnCiF9WuC#N0s9J!4b7<jymc
zny0)0`xb{jzf^Z75hkV2XAAW@fyNgIHqjk>kXjJJu5QC!WvWCs@2!w5x5G($c69qG
zv-uYB`Raog^9--qo$_6LI<$HE`f;~~2^CMnxF#3CJD23lbzCHz@_I^H!~XNz$%&eB
z3Ms7g!ff19FqSkrEHf7y`_pfOuEK`cV^oqa@Hn~-Xt)69bQe>Vp;c{+luH9Zl8>`Y
z00)Sg3hZJfd==8no?fh8;>lGSe-c_=L3k_CU9ntgk)9{qNu~CWl>3Rk&u36tAA5N0
z;g>xK%$ulJWVSvIX~WtFWdLI0<X=t&X&oaOBH4DYuWYI^lM-j$D}8#8$v*(izuHVv
zG&*tLQysN1$NPHjh#^M@r*BW|DoeY&v=_VBzcZObhJI!{z;&SaMtyf-ONzQZ;o$oa
zGG8defzDL%H<7NV>2@G)NuG0NoDleyl&)CJM8UI?EtPc-P9_aD>9C^j#((XbMg0_O
z^T)OZsO;mtCl57W34i5y6rbpO_ZCPzz5Y$&2~{zU-eT#ym`RHbY0gHq*>EMNLaq~Y
zlx>14*3#>_qBdQm0-$HLFUJfzKs-h5%i+p!0ln<xigA8?_1RD6te`8v@t9t4;-;;~
zvR}uA_xotKv7Vmx+d305-ybmNethHdA^G@kqEHt>6p9f<p^yQ;i$eK)>;6L&>K2x1
z4sY~%{X(!!EM#-;E0Z4_dOawSV#;`NtFkSu@3$Wie`OF1(+dTK%fb_vS3z6D&7F^`
zEn>cHGm>#W=zFexuk757IuH&~yZHvrwz|ag!Ixu>zAyWBkxIZgBe!7!b&=a_7o&F>
z3#&b27h70cjv?;5H$$QnUJLs{>kQ-EBep>kfj(11a*6UI*HtSRxfg<vgOcp>7;mvW
zX1tuN_PbufE$pPG-2E{Py{udQT~BmZ^jZK1u>U00ZRl#nPSRFKlW!2SCVPM&eaBhj
z0=@1wgtRVIlc%#ha)Vw1RKQ``Ta$gtLJH;tl9eo}=hXH0UFrM%TtL%7#~;bj--aeg
zvQ{N>5pxYkRf+6Uj1|Q=fGuVDq0;G1?!8Al08wsI)eSPN+i*NCWILJzf%7VGLl_be
z9(U_OfcN=KvJ1jjRQJKX%$tQb#d1Rah3xt3+UNG)!RY-y{q097=?bmf52$XmeCRr!
z;p3_0zOubvyeq7sJ64U4xbBK9?=85e#KI|g`<xpR_fkOX(w`Y0wN1Xmi0itsLFdzb
zGm}00Mm{3#w~fZjxaIdd4^(d5b%Md?uL^GeIKO`Xs>q#O!Tp~1%l6GK90OwK4-oT&
zueMqh-#RC={O+A4#-}7tZRM~Q3KH?0ESrZr`G$b9wHt{CB|nIHYR3*RF2MoftjkiD
z>S9)q55lq)jBEH3r*UmP82ayi1I(~zFoM2Tm6xIx-F`PXC@2gt0JVUjNd^c@z`lXb
zqxpQF&hA{<e-*z9To#w=zmr=CJ8R-(ia!|C$0-`REM)PP7R&m~4T=y>$$g~Ew1VE)
zzrR77e{of4L|Ix|Z0lxrZ?^Ocrp-zk0h=&pj9=OCPpuKdKf0C^go(z}QGptv>^x5C
zX1O+ULu+Pi1ehotg-ka~H~|t$;Jj^iwH38_ax(PFF^jtAwS?X%nm~}hs{ws`5P;<K
zdtze(LWtp@VT=E?3@0{~DvPs+<?#l5=4PRki9Y#ojd@$?t6eJx7lKWXC{Vewj8%tY
z{V2y(?j5bEMK<o-Z2IiVN4JRNf?Y$m%N-hbu8@+A`@^^;WFjwr1n#HAGs<Ji@kPeX
zy^oe)wgqI+f?GQoPe9c#sbn1Znk4~YMt-fMjtrs*6eLZNyw1DdOk-Nz>pLURI<6bb
zJh$A^*B=rl4$!Y`VWqhO@l}RNC{|eF<~21nowIsmYo75#nCd#LjX5bQdX*|`?5JB*
z_+_A<<|8Ra#;x5<N^ql~`C#)^mfz}k>!1mNRP<uHBKD5F&7K9jkJ8Jj??XM$X#4@Q
zj+e{&$Xo(KC!(OMnj?;E5jHBhNk#Hd5ja%J2(YU_2*}Jlk}-S^1aDO#b?7-!4EeUt
zv?Q3aIU}8*;%UjM>QmS<Qt8Um1XQ!$%38?h@28if|1~T4_vedxn_-nJr3SuA2Q=DO
zG&i*6>MpeY(0Romz!@m*=ZbC$l^hi%u9_4CoG>VQwU^8&=Lp9k|Bc+#`{V8PB?pHB
zSvUn?yNM;DfY&C2s^z`UGSJZY>ZB4#wH&khntalppZnXDwPiBj@#9})DS$JiPp~)c
zEXap!OBB2`YM=53;#g1pwXXa3Xa4X9UB<fyq__EqSGojE5jjJ}hmw+#_yA;^n-Gus
zf_{&25@;}$<@ll1q|D{Df1s)qpkU^vy6HkttFwGAufhQFDQo6g;0Kv=l!9%y+(3JI
zJF8!pw{hsSxV8<HF&i|7e=j*62-5OQKM!QH2h8P;kCJ{a2idxt)%}sl0$ASAERlI{
zJ&+0{vr*_iWt-O%@9~$|ifloYJf16H6W^de3Qde;M%oKzI)EP@4^qe6Du&kAH~sUj
z9KBkVfv-cA{M{#+A4wWL;;sw+2|oC*Juh$M&WrTTAab(*oO7!lE61c(ka8L=7S*FP
z9heF_f|-t%xH#Yc+K+)w3Xed8l188opx{R}1J0(TDskE1m?)`%3dzb+b(T2`5}bcP
zuz%4%rM^JpqtGDg)1)II8Odw_6lxN`VZrgenL$w+e;qP(Cl<~We*8~JVgGpfE{vV0
zsU53iwozzVU86w^V43FG7Bn#?j;C3l8m-vG#?hMoH(|YtXJ{d$z5pCn9UR{~Z+``E
z#?JsUk#5Ml|NSaeVXRt~a5@v<j3HcdQ)(UTE!D_&cmiyge*1J<=p1tI+`r$tEEO3_
zTP5H3foWFKP^s^Ad>*IShJC5SI<z2F@(h&gs>WwQ>y`(qwK>$~`}cFdM4nQns=Q&U
zk;DQJkUitS2-~a1n~p(RZBVQG0S(=4sKE`%YW%SPQ3)c7Bny1w_5XlF;gx`lhb6Wh
z;PQz1{EA^xpdpF#zno;hH*ktMn(YA%0MYK*alPy_eGdY$#H{u$e{102hprKNmNLQ(
z3hpYv8n*86$(w|uEQ&0NgSx&j6Rd5jWvRkZxudw+zVb>a>iD2CAlzrIlZED+4vRO8
zOwJ*P+D;*yY6c%n-vNla_9s{Or`O9m3a_W?%osNQL7w~TasQXk&v?DzH$Q{+8CA^c
z8OYo@%3nL*83mx*i=Y$)5#%xgHO6z+eeu1*YaUC`TD`RlZHC@fs&5Uo&BTAR;Qco+
zjxv|7bTj(Wvg9O-?AUWmL*8MihKH*E1`4y0Z-q-1KY9ugP?hn&gLbXrndk0+?%Ed}
z&<EBlba+#%lX0U>_QNa@${ni;r6*vi8EFHhLIEhM)xaXUtnaYGSWd5C+yOZEI)Ut@
zZ7rg+?~WtL0w0qMR??6d$Ar*0y1@+>H#BnANgz5G(=c9m^-YF=i~nw?F(Ztj46g{U
z^lu5of%%qlUk2vQ6L8?F0H}#R!2!tVN1`R{BLLsbJWv2WRO%v#{elxz#k!NGReQ6R
z0lsq;Si_NWUM0C8)1O;CTG6sZc86Rx92C;q)9u0AY8DdQ=q71s&9KGDxlDaqkWm|y
zlu+zp=f7HcbI-g9<B$E;2Dr(S)%ZM{$)`8kp^bA!2b7h*%=2D&%!ZtcKXXqJ1hS97
zVIIz-6u^iGIxN9VbC}~RPv+oT%YEu@R0SO`vf_Cc+db$3nZLFg{ea^6(^TvCKinBy
z*6TI((kn5PuYLZ`sJ|}Bwn;Z3bl^cr8rAwJQrb299MCn>pntTVv_jS11HHb-;><#A
zlAwGiN>vLSRP$V(w@NBhoS=Lfkdzw%J-rO7ij?^>LI%Z%?b;#EKv-*ca&=tawokMM
zxYf3|zL_GhDt&cjTX%DC@WBFkK?R(_nXAT0xUv@z$*y!X_B^i<h$ZCR2MmbXT1AKm
zir!-^PdR~tp;gwwKA3I?Fi&nC`&izy-h+96YfJyVTeX?R`$rGwF7YFGwTB9xL5GZ)
zC5U9r$n5)GnC%@;yVQZxcxsG-$dnA(;e{cpP?5~XhmKzAW=0M1pmdnDi_}|c1SqLd
zE7VInr0S-A+qwuL8^3jsqKuYcU~8!EV#B9^+tXK^n+sL@P3=_s<1=K4CE=i|jt}hf
zR?KD}pVYDZ-1m_69FjU=m)>TyO)O}7j5!OjMZxfs8)vZikXCviMMh@g1@|A6x&NC5
z{a*?J8cksWYPPHtzZkg^M}<9k)@jqCfg+{QpdQQ!S%P~w!pPv;Bq}nNl2)CFwdpvq
zYl=P^cT4(<z>R1oVL9yC(z)xpf|)ckWRH_KJHY<)(5@phT|X56)B?CHV!s6{F9Ncv
z6lD6d-umwGLLv*Of;@x(G2RlYN9;G$aJSS^-^W6$?w7Hspz%)4J?}tiw7`bTT~8xW
z^v=#%ZEvIMe&#nmvU_<jj)&>Yv73K(FMpn*(-&VuXE)np#W^WS(ZydOJx<aoZ6-Oe
zV-aLN-$0Y#YOdwwFK)KEk4}nI7B@zTp_^^hV<pXUb%Q7XUOYKj;$G?G`Q_m&@_Ue+
z`V77&$<X~=2;BOX2f-D7MD5uri-uQc$Q**&rxWEeYrEd6$Dg1A;Q6n;-HYqO6S7Q|
z%SVb|F>JXr7FzER9{uL(3`A6@#0E42##p=&WTHwaijgc(GTy>t$G|<5hnTAn3E8l^
z<M)=Yj}ohY`yQIN&!_=>><twOIFlI)^#(xhYN5eFC6_o)=7LLgHb@5U3dVtW_fD%|
zyWSLaE`F`F=QHVncc0uVxp8x}8VlBP;nb$Ku#5CT`Ntkc+xs2i7mhMgt^uurA4J}}
zq}yFfpbgYhnFo!cU=tdlLP%BLb_0SCi=6fjlV+sZ9C6D0i^%@mIq7o4l5zOY#bwsG
z=I&Pzcd&9Z8YCT(s&t+AMS2Z&s_?&(!x%hQKEMKm-z^@RDUP)4b*F!@0n87YWt7HR
zSM7Kx9G3j*F}}#g)knQ4;dB4^_Q{x+A-+WRmqN||C*r&i&O3sF0<wNf#*K%Pw)jWy
zg)_GiCa2{CcQfZ$6;QiCyxPS?uHK@8h9BUP5=|Zk89EbdEYE|c)16}+hp-X>CkqgM
zU%fpi(B)?j63Bf%^>^rcLgIp+)wpMpFvWR+o7grx1&uQ?Q@fNp<(#{?F$`5@*I#vr
zj%a!#Tx0i$Xe~<6Z9Md-joF0#6uaFilbFXP-JP+8<bE)28{vD<Nm2vbrMEzhd3!c<
z&f;@Ky-5_Xm|ne_1AdE`;S?JYCu3x3Y3U<<`$7J;#^oVf9)UV^S>^!vzVQNh&vm{-
z^0D_`j5<;S6Cl2+Rg#H(DPY4~@$hl)9lRF~PxwW2^{IIc)$CBXyw;qg934?99Y5U4
zFK~c%2d5#4t&O~iW(d?yg<u>~rEf^@kqh+7WtbXQj2IsrIq#K=PE{`_7!PdN-QT>O
zrZS34%=&s$x`ghY{fUXiOy7feHhXiv<*^M*jDIxEHmcRv!Cbv}UP0#SE2brZZ#G76
z|B*@l`>PA%UM<8SEUHw=7-qNdo0A|nKp>|o8zEbgxQJ~c@eNiSQ+cr)J_c&Ihm_e|
z$|PuttwXHMoTE?dh|IG5Uscc1HK9uzW&^+F(IKD$ei<aY2a1@0NeJY*;=D$={Om{5
zV;H*{Q<mo^5pT_6J7(sO{}NjC=V{Y<dj2{!W4$PUJCG5RV8<THG!=zsM;51I6lInV
zh0-}%<4}WWNK}5#!~DM}PqQ<K$}BC?iuv$}(rK%$X4;Xotr=m)I4w|R8k5h{25fLS
zmJPFD>I0IurG0llN%!<SN^wAeW~dv-aI?;K5AGVYB?dv33=L68oBOW&|MkM4OqyhC
z?O$V|LC^wLUTL2lkWAiMDjRNhB_}FBDrwL9bL3q1Bgcj7?o}<yN_DA}lqv(gX4J7x
zj!(NyNkR*UwI@y<xh0%+E=kk$;e{FdPpQp8w<h=&7IFeQ^{=xFUb4R$A*;VWTKJhV
z6&stK!%Qm}Kj*MOaI3@Rkh;zzN4^yP-0xIFm@UH~=|JuBHaGfd$pv}CgyKhvE*zXM
z1G$Y%N<J(-cC!;RJU`f0z2e%N`c(MmKk{G`_{p#_C$lHo)T8`oWWxy-p9L*-G?63|
z9MM|Qh_%;g;?zW*mN7{ISG8P-E&ao4>*v3wAsn_KBD1dsed25j;brzi-?gSpS;=;7
zZ(QI~+MKDJ3;VS2n2wj#!Y|zAsE#M{v{wG(CGJlYojBd@lDx6R`KGMp2%)i*U6$gw
zs&~iUt8bZ4vq7eB=#JIOd`{w(78@op<D-kwZsq>skFKn9d1So>xIteJxxkOEUWXgM
zuO%_h{K}?J9(<B+dFRqDUOuu**dS@z;FHByL8N--d5m})UxjPD9>&qN*uHIq$E&qw
z4_x+tY?c1;sb*(TJ7(sAVR?~xo8V)endu(imD|Tir-s3C#lwFYG2~_xTiuxQyHyPJ
zW&HL={{ENS@P3K}Z&MP(44i5M!Q`vbW}F7wSfta3(J&gs_B8gBJ-7eI!RRMHLVYiH
z4ZYzK#&y9dOl$ugtrXc>6zh~0CNa!#Qc_z#+pE=k<0S$Ql>FWxXON>+&{n58-PH(R
zHU5kTw|p!}Cz@d{O*O8fdP#fo7f#~8J(ScvjQiYrY>{>xUu>Llj~J$zMrB^>q+(Fy
zIa$0;4QVZWl9-g0mh`hn@W-FYdwN@%<7l1eXG&JpL|;?54J!l%1QK(QNDSQ*&9eAy
zLmpUR?<CJ!XU<=kCI9xGUSHvk)59qJ)qd?V>QDQ%hQUd^j$5{x)5iA_WZu4#U|tHF
zr6AM8e@?PpX$66IlP3+fX09_W$dpkWtwwN<LjL1L^pn>TCdekFi+NyhUY~wefT=5-
z2ZzTR2}}sS*O_4>te~$9UcY}L&t}{-X-mmQ&*V6p17(?wP~l{+#f=dg$00>9XJ?s4
z#kBS7Qz_GiPLiRtZj&p=-6uDCB-}dOvD?}?uxMmWrYZfr<ih)&4~Pl3=#G{4#&Bun
z`wkmkLWFz|N{l(}+2@YKl(zJJvrJ=T4Q`BcybOt_RM<5MHEHuWkP_wbyAj$ycE}%J
zy>EJ3?mMU@c(d`gXmh(oh1=qkcX33eW^4#YrHxTJHgHk)#J;idZ$#2))9)sHzu0m_
z`m2Z%K}$;HEYpBfdXoVSj_8q(C5E3G$-@jxmXOGjrH`sKf4yVn;Za2C#cyi|_pMB(
ziMC7>DMh^gIb{=p&NW^Jlfm%AdM+?NT<GU}^|u$*%ItSph65bATRn_SirZg-Cndpv
zyngY7N0OvmyK63HfCu+s#kKR$-}m`nU$Q(-9uJo16Sdri<=|E2_5j0!*YU!%?4_S&
zBI9K6Ta8-ZMpB6Aft=|ix((mW@vy5wQ=hw!=~5mTte}v_m>q~Qc%UT|9WMU`rdbF9
zb4V|{wf&mBMjJhp-4|DEQSnQ0wYLYlrkVOUYHZM+cvM0BwizdJ@-;9THzt{sGEio;
zx)gr#V&K=kb-8aOUEsl*m%5!HmE#m$Sn(d_*v1GQ+(%@*8U`gS85)0T-#0g@UsziI
z5l4b{M^n1yO33D{eI9Bks$Hkd1IpdrP!DY!rCEI6?D*<Nd$(ryMgGea4a5E-1|rjd
zOfqbCb-P>JQDlnv<oH3!b|i<~!koEL9Pb8UopB$kPC!85&{qEmCX$EMfzg?=o)0|U
zp-LXC#5SE3)L4umDQ5;&kYo1G-KBps_wttXey&KqeI|Yz$tg!qxWpM3!hs*xrNIWy
z>>stmFJ~>kD@AO0D;yV>p4@61%IWopb&bCVPNB;vO)mOb1b*c)N-i|CxxI1Jv}@yK
zCRup%Nqef!CXxcyo}&N_NXl^@Y~$+={%~(xNSpGfmyIe5PxePmQvm~1N9qH>Pj{O7
z)&>50Of6r22x72bJ=f>ryYCcFw)^EYbNp#r_OEU3{YIHPBPB76;Ok63@0tGIK%qFl
z1T#3x_Dv8;5i!ge7c<lsdKWI;zJ!Zkh`vS@x1*Z(sl`gR0Zh$CFeCTs{r&Z;@uFsr
zVjUaK`jP9s&9?n&7nWV+3A?(O`M|)t$OjcqkFgj%)z3k2>&q;PqUR~0G@tP&<53zU
zQ|j^;|8NsrEc0jU1iPX5rpmwTrF2=udrSaPEw`?&E*-`4>z!fAPuslRoTC!XXZapF
zXZk5H-rbUW?>!eSl00K<v<B%50uMHR`d~5eoN84?^7^rYyx=h_ZG*u%-%sU^_xZ`u
z@Oxm8S7pBlM!^~w4Fa7@yb5GPfzy&9ifi=c*b)=26c75j+Sf)-+e5WFTEBu5lciOh
z`ygoQv1_>ic+TjQ(@(RB-=fTMGHvr0NcaTs%a>8~B-F7OiinYZJU=Gm5yOfni~roZ
zMsa-03Oe(h8NfO6f3s?zCJj0@z(u#W>sfG)x4sMim2*0E1-w4LHJPK#LNpTjeZM~m
zPB)qRIu9_OvZ{vNx6feqErD?IvxyXO)}^E>bN91=fJ&10tk^D*YnR`3r0CrQn1A1)
z+Bs6OQ44@85gSb3_UpJ}{GBc6sxuhFrrUU+Si5E1DSfj0>Q*khvd(afjrS{*P})9x
zAGMkK@C}5Z$BtyfEg7D!Sf{!jnuf}>UkF9m31g>yCiA=R)XRts{`zI>4nTG~#nk2T
z7OUvo=DHVSkt!m$uTs#xLrDQlr^xcX)x?7S5~HNEy-omcnOI*Tg=R{C`Sv*AC-Z;>
ze>UaTFPH2lTGbcwH6zzFn=-i#a)=!7-4-(?<9Xt@;XNLg>}nG%pp^BlSfS^}-0_sT
z)1$>y7r2R}P}xTT#2C1*5MLBM1%?3D4OaVnf4QV!U$FHUx4(SXybZ<LNuFRYgGk{&
zB~UA3Sk2Vm_BJE_s4ENCsQwcx>%#Tral3Fe@hts2g?tucFfE<{GVPalDYU=d;t_|~
zL>G#pE3DDRu%W50*=I;J5Zv3)@s#EgMNd+^tq#`{t)7n&U_sXnhTeNKwB(?%?=QnS
zxPiB`_2#c|<fPi5_sw`t@D%$X+umKje!X&XozwC$ttYud=@UiliaqVI^p1*d58G?`
z&@(CRai6Qt2UN&;)d6YH9>}i~K%X9F*Ykj8o;5Vcvh&(+2%<f~GC~|gMaG*Fe97Y-
zjre@K=(aeLF+kYF9fmHp=(>_8x>~3xS(jLV_o=-S;gO7>wx|=|xPyWAFHbt|43VA+
zBrDMaEgo-0N`Mm_ZFs)lt-`d;O&;TsC!D5%3Kq%_@>%v}mF+y;vYu6q2=2)2$h#!;
z;>C-F6uC8i6rF<oCgeVG+gIBW(w*Ynwx^<@DcuA18_u<SFLj~Mj#F(|fC%-t>evGv
zc{wm&U72rDw<{cu$YB=7Hc>rYF(u1sGRtF0&C$%+ZH0NbvBcnX^@4jRep&PwckPC}
zR>~XlT3t%yG}Ch#%Z`#qA&{oaarn=rU3*VjVVad`)rt3yg#sw`K8es{i0r4A0*ymE
z@CC_-%fV(QRANveIydi~zmKT*qa==c0S=~{KPBcC2$Z;9_vkWv*#-Wrrr>9p>hc*M
zf{>A9nxk3=cbf!q4v5F94pJ?eJ2Hx=ik!>o_nfQFE`X8CBn0F<7+O_%bpG<G>x$DS
z^3Rq?KgqAvFf=I+A!|faRQ)~ZzX~8a1uH3c2_N>SICGVz2I=Qnn{^nvWo+LkS~&$~
zy3f?nqYf=<66aNWCrVbP^ae}T7WAWGCUl=y-@X$}Vkhb)dgm)*Ccz@nu6Q#4GZV2*
zWjFNtUCPZ+L#cfJr^n+qh~kp_J_=sfX_`vF(z?<QmavC>ypv}oi)$?C(4O=}*f}BE
z(4`FteD`<1U7d0%{anoc#JmjyR!0l1*VJF!UuHlc%SIYvZIltN$+)$JZavetYSHGg
zl1`5l@7p)cN?dyjJ`ypLR8b9OPN(ZvJW81AKbC@3#i3BmqzmUi4<Bnv`D<$V_t?ND
z<U2@%gJSF(N48tvlmfN@($ky~su3?*7Ox(s<W$cuHJN*@+~hYW-DX`^@Q<AUBiTGv
zVch9;#4}THR_4T=e45^JfFrF@XZ}JZK$nd<rJNr}JFP=^Rz?;fVl1EgEkxk<H@NVz
z?b~|xQsANI*kl$~f$4mDs@izxk503DHwUZN5fOQFb5VI%otTct9qGecbFmg*Nc%8)
z?`XkCQYg>nzIwtlDTy3jx#D_1eV+<seFV4XDdBpX_R9r)XC8OhZXJ-A`-(OH?H@+8
z0vNh9SV#eJ;z`+6zA&+21Mh4_WV{K+BF%%tXyL*N1Uwz@yhpUItR#<gd@l4n%zGuw
z0@lFd<Ib+5SAIJj3{l_tRv?Zi*>Eg7z?fr?^&?`u+tgWo6Mv4xH;&g6$V9Q|^>%&x
zJQxN_L}|s}G&S_NpMK!eh@j{gpq%Fq;taePt=^W_J&_<-x=rTk9Bc=eYRf{emlw&p
zNM-6I*!F@kVQAHAr`Ln;tRq}2`)4Go8xHO06VpHZIGB7GYaaZ<?deUpyQd;2+QX-#
zgtVv5J7h)7My+*vsax~21P`76@i4{@o)<0*YmPM+Qhz-xW9r$6tiKVrsd2A&1RuQQ
zq?Gi#GU2u7c(962tlzar-o-=?ykP1=1_PN$nv}iZUGivoy!km5sf(8)VR!kH!5%vr
z-m}N~K#AS$TzAW8G|!NZHak*Lnzr>~9l4NkTu@j5t(c_9c>r7o7d_#W5@+f5xarUh
zDoA5TvcR@mb*LRW`z=c6O+2y^^;V)@$eDcfJJToJ9xwi@?Akj%Q~pMIk&g|y-78>y
zT<QZlo@i*Lcp^T!X$bG0JX(#uQf-JixgVoZ%0HZj&U{3WZra;(aUn!%%Cc@crsRM<
z_MUbut*g-aoWT&O3*;z;QoJ?#{CF=Hvd>%GqTyhR?JCv1+UDkLA1FBG?NXO+2H&dN
zrAzhp1CirVdA;vzlt!N`o0+|#I$1YIGk~a)edi0)UtX};<=+cN@|vJ6W#H5VN5RU3
zYu@)xC0EuVt(UfQCpCwCPL}j`iZ5y2u2(cVI1F+6!{-ylU*g<nYb^uTAh?@Cw6iH!
z9S_L8;bLfi1Q6a$AZWyiD^G}AhVU6r9&6@BP?w>yYHzBdM5ciUxh;u22T}G@0jtz6
z^SsY*<!^WwD<bKq5MLod6&nfnE?!vc=P40>I#?|ky3nS+;%SKEX=?2vdtUJ}T;B-@
zz)#eO4r9D%YNS)U!Q9)JwKNhPji^mLP)cz4EY!Tc3je{LODHtlw($ez{Tk#1k4w~L
zgy|P*qZ_Orn-j+sei@<Vx#Q(8C14pAn5t!Lbz*6qSqWmgPJ~`1_xKkWaj#TN=(X5O
z*L+bKM=>W;Vx4cCCX}v@8~w<Bp?#wkEUb+o5QR@tBeYGkTd9ASwRWj_wZxkmrNRAM
z$ZBU9Jbsx%M5uW`r@co%CBW3~G?7r8kElZT&><%UV;0tlNnu6`B}A?J2ofg4h}Zgf
z|7WU}$Bp$7$UC37+0;|yR{L4=YmY>CdaciK9gs%ey}t`zx;ANlkIVVjsiLJ7ZF3Zv
zsgolUeOom0m|sVUut`$JvgLTcr)Z^)5j};NgkqhLnV|F;u3ZuW(J7VO%W4ii6sSAe
zt3tW#VHBU2@qr+Tx*RQDf1+e@z;eySAasLMMs-)vS3CddsI{qnECU5GaMYq|#nzRq
zd1fjHw)^?f8OI~OZuY`vQr4}<#(PV>v^zlEM7U@~Ti=eO!^R5+bK<Z!3qm-5wa#fa
z-*_g^-Y$4wr(mkQ$cqk^)GPIr7R};iq#P>+*I>~$?w&R`M|7_h>1{N!MQ1Vfho3iD
z124yyd2!e~(`i@r^dcwfWPeq%ZK4&r!2RYykMDhIVhR=2YaPu$N^^fAVT1=40{!gK
z)+~I~)pkQSJ2&v#8{h$CYCed1)jC63QE)|y8c0K&TJ)GU_@8KU-yY*fr=|wQ6)QUV
zQ%Z85cqt(YR>Tia-&>plGji)*Usnue-wJ}Ta`r$s!l_kL{LZ&CQqyI0laUs2S#UVW
zq6|~wP}c2DdyL$hsnSSLNw{mv{OPg%ldeuKyLYal6a9DDIRkwmw<O6P+x8AjN4qc5
ze?e0FJtpxaYEkrzVM<15hv&7rEeC9k;o!va$9MtKH64bf&duld=s`g-(Bcl(f6m=@
zAG%bI#<F*0{W{T?SKW2-XvKXfeVYvWi_O2ey~5aE_V5V6Qf9gq5JTvml`{eOXB{)k
zRrxRw&z{U_l%*!Z-LS(mKqp5}=`G~R65sCnPJ+L^9{J#}Gl-^Vn-e3+sE<sYc^7bv
zVd{6<-kL&1f#`EH=F&Qmsv{>1jnUWfwsW#i?8L%l&qm93d7(4%MP-itGHx;E-u6DG
zr*jb#NkTM@chb4iPYTrb;iNau636XiZ4CA47X|iXWC@Kc7oNEPI@(bCO>fu?B%W*S
z#k@ACmi0AMD1P+Ojdfg0XV)@nG1K%(%U(N<PB#rqmgfl)=D&;-DnIufhAWw<ja*<N
za^#QipkGNa@VGw#y~(AtYY#A{ti+@Ta`PP#zuu&qXuJLxZ+yJ}kMYJeD{)-l^maN_
z-cdTY4ZGLe`rO0b*ffqBL3fJTJ@yj8-)i@^ck%fGhzazS^P_WtA!{)NqyN&tz9{$r
zTCFo*#h7}v*t6Zn;%){T+SNWVT9M5$9G!LUO{-U0-*|2m26@FHDDQln>eF;KVFvn(
z87Q?H1dBR!=(1o_M}@CD2|c&Cv{9Y3$=eoMU@ra>hV0qs6HC)g1Ye{bH1qT*OsgD3
zo0tzPXR!oK`R-p<oHUz>^j{GTf*Kv^C{Dqcj;u=+8N}A3deB`YYO#Ms8&q4XE`&->
z|FYzP67H7w*p?hbzKt{12jve7?TsDw#J;cSP#<KTs|coO=&XB;ecP3dmKn-BEUN<&
z743ekc?TM~33Hb~hw@)eqnJ6m8}XD<D3YaqRcRp`EsQ04*hEaN9F;4x615NDF>J>`
zh-w(<$FZEgK;tDEMwuzu9J0*U?R0sgE0Od@n&VhFGGTVM0?o~u4(%MGhj_{Iau&n9
zWatMQqsdzFwvD>quMHuYAq7UQWxh7(FIwPe7}sT;bhCul9D1#IS+J9`skiY>Bt<~-
z?XM%k1Nlt(Tw@%qGlv~V4f@z^^?-TnInQ_RF=d9Il#sB|o?L4#Y|YFFeX@UXqi2#O
zU(++Lgk<f&X?bJY(<uYx*pV7|$+~u8NrVcww(rtR6M3YZ>AVdp@l7yTxG$=!Go3lW
zQyjtp(WJt;7xkWGXGqeQQ=dK9T)VW<CFs#Qjkg_7y>!AT{F_dWd5z%f4kd3a-eUn9
zxLPvwgqVjpi6Gc4$ZWK}9Ox6x?q1LME&bMy-%f&kGIe98vXi7X8wPrKh=G-Y+pjT>
z=+bzl>W#X+se3NEE@r;&v8WRa>c~=bp`TBqbj_xzH@t!({liL0$M~wie&vl;2h3Q^
zJw$aW(}ZGy_d3NyTs;2tH3A)ybqH=KAF+zA=kmO=@g$K=lzg2XE2u&7@SnV4O0Z~i
zb7@=QEu4QsT-6<IE_oC<Pna4t3I2PL`L`31Ol!qD%<=xHFOr@Tr9z@939vL;!(B0D
zuMupeELa|O*NiqNpfQgcKZdgWm*sJZr%2d7$r$>sljHr~xC_YF@IY4xMjq^V!5SUh
zqlUq?JhIKX|8_=9=6v@UaXS+J(4s={fetq&W7+DrG_9knRo&w{3C7oJh;P+8W(*sI
zp<CXTPxk*O{bK5ofeF-%tiB<cY0yI)N5qXudp6v@OPaL(WsV9>Q$y|>wgijDmG)?e
zfnwh|${@sVB2;+DEx-gxx%+kvW^ThFo<8>*ksc*i7;L5r22o(NTPvIQP;9KNw>uZ(
zIHo(Owc6Pj?co~o>$Fw=&*bPZd$u5!^2RQvn$D#+V6!X>SteD-XmUKk5ru24f)&(Q
zyJ1w`e3hv!yx(0E+fi?hTf~zkwJkBG^wWqc2<lej)x?x_l*UGvp~F2a@klGY(Uamd
z;!%YQgp>cg2YU@fqEo~*Y1s?<a`B;N8!t2HaMMpRwTi76&|qnu?QmDBt*^;Vu4qr<
zDTyBO=ixOUsYc2Dm*xIHjKwdu^8YXvf2%S6hq3s3aQq*};$PA2e;AAZERp|VEdKK-
z{%?lF{XdMwUwcm%1<!Rn6NlbG4RmFK+yk)0L}S?<M5xw1OCW1(7|$W)wYf&zjs&i?
z2ed_ix^r3|8tis2w6tqoC4m&01E^tLU=5}lm3p>AyE;a8yWmJ;yggO7<jD(7Am(Mj
zO!nRfP>aX=ZQYe<8kuX;(Ew`xoQ2h~8_b!^>A%V{6D&&HkeIs$646=(>4_Q3X$A?!
zAs!D8w0%!7WgT*w7)*@iTRq>nR>K>b+oogGgPI>R0msJpJYdV5z|CKUk+ACg1c)J+
z1HB}_UcCFu5%oA*7lLbwfkQ1{JJ4Hw8rT1S=X-Q0gye_(JqGuml7ac&S7`Mw^u?d+
zO;>#LS47o#H@S<%)WealbN%|cglwW#YX=1v`q7oX5oP%pk5fN=%w1C-xM!tjKA_@Y
zvXqyRkGF0%Bd>-^O`UODUmBeZQ(}2Yuq=Ri)a3JPSF&J0CQWqw%WTh*kRl1UeC!L=
zxxg-v(>Z8m?Av|`V1^ak>2d1FV?I&9Eg8`Wia557vMcG^51tX3s$lusk@}aap)8v}
zZ1%MQO%AOc>$g0zr2l6`osE%cu2%5^4yuRM1ligwg1w3@IYv6QgG?S#z!>6e7bd!z
zTb6)>WCyHOY6G`Y-5wfG*%H0(r)2LGoC1nF6}6J>gZh7*y?0ns+qy5jEU2J}iin7S
z*idOI0#ZU0mLdxgl@fYH6p+xA8Ul$ZMM1y@NR3Lbq1PlR5s(^?5(tpc1B4{B5Fmwb
zdhR*r?!E7K)_(5&k1&%b8FP;Dj`6;~^0Iqsfnq2N+rE%%PrTt3<~r~<30-K#o?zu5
zv047$%e6<d#h+_+cW%he!?2A{gxF+D3ya4x1@@DPRbTz+z|h5kcJBPIIoXqdm(30N
zIxs{Tr3RRBfIEhe?0$%U-#x?WK3YMy5)TkeC<MK9>dU>?^Gr)*^>28CnG$%#2P8|i
zX^BSeJ~*S`9G0VZ53z^Z50%Hps(0-O5o3lFqK)~936}w6-L+^_xq9Ssx)DZdt;nXb
zEhtKREs0|-I)07H`fs3)62h@Z@Y$rv$!$A!S#g-78BTDZ)5Y0iInu*;;Li91c+a4<
zOPYj~n+#X3UMUvF8>AA-{E-gj37n{v<fY_F-OvQin+?#Ux}wErpr1*We+=`y`7@fc
z|CCF0lDDz<QOwYxA6_$A@Xlo6>Yb5G$;#Jx&JM|>!rvDM-v@OjF9(#K`ANt+XqCV7
zt8~Y_)cLm@sYN|wJ%C@~PBQos;_>MQOCDP_Pjl*TiR;h)>co<?Q2MS4$X}`pit8@a
zZCl98Nk0Y_@60zXzJ%E&L%&(N5rsEZ&QN<g@uS8XwWkQcRC|{G4;XH%hV^~7oO{c0
zpEsg%db-C}oVK=QgFm4bU_YqGb)x@#{?EYMC5Q4GjWt%Ljj$@KTFKTXn>N^*(-tT%
z>#EXwNxs6fL%;8d{_;QF6BvBEuG3DN1OWUfe-YFf3+X8xFe44@fHSzI&RvP&i}o!S
z^zLv)7SwOr3a#Fw3h{lhnZ^JDWgj>mKJdk0H-N~klqFz$z}-MuHd*}x5)dsu9ZYA{
z0?ItqI-|md^F090Hta{T&oIObTD3dLq(Yvs_}SA1Lx%r*gZbybtab?j_c>^>xTuli
zx)!`=M50d7n`FQy=ilL1SS(3xAomNA{*wpfX>_>A2-T%U`?Q@6plT|~>X<X0!AU8A
z9#E@p8^g>LBmn{`$FBg8$q=yMpo?>Wdh&|~V3aO>#r5uhVNOeobfVf#q;^hm&T~QN
zZrO{V9Do5rTh00($s`Yk4*hG164(cbCrBDnUED%=n(>(-qRXJ_TnUo5zLcGUogWVk
zUVTJJ1Yq*hLA~Suh_RhBr#h#2M0LF<{nD}tK>mCyui-s*4F;H4t==>Q45l)qNo%t`
z1XV{?!xsL@oV3JfjX$tD;|4mRPn#qr^%nleQkPQ7_IsBx&mFea|1N@Zo{tg&#F#kf
zvk2Up#7sdhbot#r251C&zk^;_9t#qzPu@_){3nd2v;hdzQ}j8_QH^T=A3|+2^ZUp1
zW?#SQ!F#P^zyR8iVdzBrD)V1)`(Fe4gQ3H>V9oW7{$jlneE{KJ+yNkCufGZMU@v}l
zu#JJF#q~cWgfuk&x-*(8{bmjU>#E5beL;)-AF{a<i<5gZL8*|z)Km-B_aH)1`upb7
zbctUGT$RXNe=+hus;J9<SLOPzD(Wtr>eCF_WD_7y56KR>oC%Q=<AOdx?3a)0byd6l
z4HMxxz<K>SXx8(tN@Pa89-zzA%^&Up7}f0~x&KKX!W2~(#5Eu4Gqn4gqW=lZwJYTS
z+5JTz6rm^8jW~emk&uw+G1A47LYvQxneJNFqa=R2*YK$RZ^_wr6%G&!NnaZMfM^Q6
zj@`XMb{oJFn;}r}+H(iml0TyWG?e{s5Q9I}=={3?H*-!JKpIKEd4SzOU05#1pA9Ji
zPB3U=HI{|%-<ETMg5CEZp@j?N3vVI!ex~o6`%pe<w%56@03EpqRQQkOeD%q*w{5uD
z_wDaQ2(N_nndyif)?WSlf{LtJO)ue{?;uw(rDV68xXt|BJLA~@M~1i_j53U+R3p=;
zw7z~=`McRswsU@<!1`{y9sX=B#<}w?<QgV&JG>GA%EdN9TBZAe%^Y|@3y8k~?)FTH
z{MkO1Ycn1MRO+hqq$$8!8>u`UJMUX~!htI?1Ny;v+IkI2vqXU-|NhaczFl4f*r&vg
zkOLS1suG#CV3ki>pi?hlLL|I6AsEtz#g)G;*4F~;$<0S4%yC?R#RH6gKLT9&BpbVX
zQT8V=AP>+wBn8Y%{Wq1qNAr2-0wJH7T#@0*W-KwE!_4OxKAV&7-ze?M2$2w*!;KON
ze_LV$fR8rC2d2B0M40LyC_92hd+?ixwB~bfA-OC@&z<$J8l6}OR016?C-ZOckB|Dk
zP|D5kb-NeHB*G3v%;GgDS7Z&>uz9Wm@)q#OOl#r7=%iQ2{<c(JdX4PT%kAI*iWy=A
zfCpW3ux0lS5crQ?VaoH+o4J%72p|&F#9`Y0$73E4oPKQYIi@Z$uFf4Lz{Qvnb%<`J
z+T?EnzXSkh2lXR*;Jnn<G0O12VKr9_Vu|UTB2B~}EZ8rgsJqStSk+wQLis!{uB!Dd
zl=ioQsOs8Zj&+gCA|%jV$N?6h%lHuDCJyT^XsCVyrFEA!7p#|}HMz^j<^SP``Y(a?
z+Rtt?%X{|@8l8It31k@$Uya+%#ES|CAOD@e;K?Kd+A1J9VU6Sdjg&w*^KiZbVdGIC
zCZ#iIsge#z8UUu|80Zb@s#otoT)!!w{rP{~o=*HmV%oe87o0`&ne-0s8-&<&KPh_i
z+*=?Lx%6@2!EdUNdUEZ5Kh1svQ)GaBxmLeDP-uZ1los2cjU;o5$d#-cT)k-EF`LA)
zk^g487uk>Avb<iudlk8G9dX$gvIi>rB3O*A{=a$Omi5j5tGJzj3?<JCkMBAiZ)r(6
zRp>H+e_~qWT-87DMhuo!xqlL&?y+!rq`qn%QBWi+Nm*b%cs!?P;*aSJJ~)DU<xpO>
zns4&Hut?Uc(!z=GX>p4kwV0e`=}unnc(pjv5(&dRdMrWLcv9GZyCS(`_Tt&{v0BWp
z%%w^TY8Wh%<}lEDe@?y8#|yH#zF2N!#<p0uMjt62Rnz5M#0zIt%@5bXYzr2X+52g;
zl(3$0){PagFlOjaMPt9}GE2I;hdcYzVsfkU?YG@NUh}Z@4c$$6xq0GZGDe0+{)pr!
z=K+&jBY1}z-Jv{6-B?aKXuui2pUSBzA)U3;;T38u(Ta>DGt~Ym73$tD^h<;q(iznG
z5weG+HdTrFx=7*v$=K^mRtzJRHp4#y0=+o4&z$yu07#)(W}lrYww9n3=7DUJH|Pg&
zu1q0zQh4cUY1(|7PEpW6@6*Jx<uyx+<MS*s^9ZT5_u6NTk?xSqeoHkDuI5W&;mJ?C
ztNjrze&POZGdRcocmsWJuEEHeegI`<`99opzrG2$l&|O|iW!Qw?wn?DL`dKZ1uE3*
z9(#fdoJS5J9h!f1K9*1nC-JO|D=FuS6)Vg@KCbI<gl<7Cc64C87M*O7$okyjY}MZ<
zUF1wztf^J%KdZ|kG!loIPwl^?C2J9dsuB9Gx|+<B)vM2P!WV0d?I5l>+F0j)A4->-
zidTbajo_fQ-^PC6CrTFc;}(-mUZ=EQsI#q`{PtcS5mS`T4%W5QnPyapdMdc|PwV80
z%A@)#=mgl2#x<cVC9FJzGI!3n(jvX~z<+rG41F&U@dQkwoz>M?Vkl}sEH~2zBRA5e
zG#>Mw?9EVYByMt-tQa2y2En@fyYeUh<xHLM8|yn<@mmdGzpXxM_mXTMq68{U28EF<
z`Kx#9WyvHh&<{u&+Q+(i2J!oBp72*_vXmu=pI!Lbfmj|ipeS#JE$GRyQ{%P*|JmVI
z;1Yhq=F6jyi-WVT-DnX{Gp_KfdWzvXVMEiFW^ylP7-qR;RTu1ZIxLIR%yL^!Vle4i
zrxkNaLT&_(gZgCg*jmUEy}zq^UaHzfh<)s?8fyh036-x~u~Sxp@7%>)?=Mdmp{;vm
zOcprv)PN8Ef$K2?t;F7Jxf$yB^0ULsd>663BveJul82jYhseD8weJY_8y$kCM&9~*
zcQLXR_>uD?5r^fZZGhYMR=f{(mtCmPsHNu`%<J%G{CO9%tukrJ(xMHf!2*wK4*^0_
z2oX8DsxxTynlfm#lRXc$RZ|QMBPqE@OYn6qAp%9kT*y{3934jMtFcW<j`VpE6oX0M
z@LvCTou8ueuL8mLvft-DAT!8^loTheiVTC^at=7O+{<k^@kuf@t`{HIgWrw-_EY}V
z{HeX$_f+f&t;>>aJS3S{?3nZ_TRGrv^^frFEwz5_XEGsPzc_YkURHZ5n<HQWQ3<){
zV2$hKe3t$n*;%sL5ob;YMObGHhrvkvB=fcpxk()7(Mp1ni!tV5o~3lc<-+2)gx8<8
zkVnDtcJ;PL>y2uBY42MMsR1)OX969AF&E7O6W_PEZ6qhxsz$POl+^B31%Jw`zhgwi
zIa7wU#<QU2Upxa(B0mM#s?oBr?EJzcuJb3Y;pzwV$F595w)u39Y&G%QhCQX6FUUzR
zXg32(@aq_S1~;zj7wTl4?{URev)_}bZ!ocW*=#n%;Ba8j<9xpcSATfL=@^Jgqemw%
zE~C7^gKzr1+!8`Lh-8v340?{M7Z;_!tF|vsRQJIR5`#NO9N{hbWkEA9$6LG}efKX&
zlOV4&2xpAd1~r@9K+V8rLaY`?)XUMr-~&z6i+Q=NU<Wlku;z~-?YM_^Q6Bw2Q@;)A
zkUB)mr`xxtBjMFe$N^v$Tho$=%dycH2x!sDq>>Kv^!w6CT7jb1-Ue8BVtRfO$20w%
zpGAK;dVd3910_2j6xPt&sXUggseQp~KNUfILBn*0op~wpF<EQeCC|Nfdy!wiM5Wge
zcM{70E}ppkLg3|N|5S4iJ)-i~@>8+5!;LRkVgzSs$*mW8_Csk@R1|PT0t4ci2UNOl
zDrw_N7jcf8pHp!y^rDl6nrud8Onc)ooJ2?wmVf;W>Xf<<w44lQg{i+#h^P#&4?pv)
zdcW}*cL(x%NwJsTo(Z?hB1nRQ)?s`V`0CEf1s^ri9ZZgNE4AfIX+}!LL0g>Ke>uL6
zj%^Ue3}*vzO$O)CuU78zGn?%0HaAT?f8}&B=~$mdZ}Gk_2?OfIs?#!SqT3e6*%Cr)
z`7WTNFLHL5+qD1M5;0a!y{F52bF<H?UraKrgx_AcH0_~Ty*w>=`#X+)oiS;@E%N2*
zL+8MX!q#Uk;hOuZ+BHuX6uXhLtV1i0wd?PJ^h__8m<8L<kvGr-wPzC6y4RQ2>LW>v
zYI5fV*`p95RyDIc+~pK$AnYPy#>v_#<=JQS%j6QhfP9OFKr8D4(Z;1+OHbLW-?e6d
z2)u{U{~e@MdM|U9+r3ZlD6c3<9EoIA_*#i%m!e4;>W*3oLqqbeomf+YMfeAcLT`)Z
z3N5bZtZ3z4{XiK~80nO?n>6qCnc-!Ip)vM!0=$)!V`Wb`;~d5I7|hP{$QN%PzT)n+
zP!qIP5aV}#(7_hu@dZhl-#*9t;`=>X#r5uB!$mN?a;2eke$mx4FP*LL6B)6kY3h(m
zqj+1RvvuFy7rZ&A=--$ORB4_V{8OY(I3HT!4DcvSBUTRG{aHL_FDA4;PrHt-a)b2X
zoAYzy{whP0%`x8SvPVL0GXm%yD8YR)d9LR+&Ai^8;6Hs6{V^dTH#yipP_$s48=;<{
zz87%IETGdx7UnWIHa6dlE1e&837325$R2<3gOAhR(&#wcbz4tSm!|c!UO#hQi)Gam
zMf$kPn+#p}sPx&o>vtT55u}y-<Eu4~A>E8#MgWl#X7Aa#=Aq<`DekMA`yDzJgZrd)
zo1E7bXT6U0!3qafi__t8Svt@{!i%iBXRdc#3%h_vBf_~IqP3H$bL4nI#6V@-V<C3F
znKuRo@VH?zjH!-iF&25EnqzN9uC!xs<%v{@Ca&G(%v%$0sI3;zu(C0pZmxxz()S%@
zR)BVPF?&0g2d>(eYbzG2DDxoCtp;X_7QvbRLaI=+M?;5;N@esM?s~hge=mtjUieJW
zfo1zRx6N6TJoD4ginYqHN@u>~dig~<v41mRu^f+Fw}zg&*ZV+oq_0w&r)87-F<|}i
zm+V{z<I&SB)3*zDmZi^X1jP3iLtMw1dStOk{OWQ`cmN%8q3?LYm@t?wIuOk1s;i<L
zR<g`T)?B_qBo1d`3CQs?EOfO=e2_ub-4oCwNXs@INtD4o)UE;N<{1#`Lh!N7Sp~;N
zX`)51XRD57{9IQ~1iJc;&@jvyEGu}ke$ESFUC>WJ7e&r^thD9JsfgBZY^h{(Pao#O
zds7&|9?3R)?9tw)6QS9EryVdLxQLoJNyry%H=kClOHv0?U*xmxYT2C?@6aJ$<riFR
ziTF{Ees$?BO~XUu^{O|A2j5K=h2*Ra1f)?0o^I@Ko%zb$te$-(hA(Rs&$c02)DO+`
zHxDzYB})aSH_4y8{3bb<ZQ*R$Dso+c#=`y8b%G<BT*GP}{!0<#%GZRFF4#a0GtlnA
zjMtisl<`v@%+!qmSfy+g@m>AdlxQYo*NUVZa<n;Ett$cg<wH^VT=H5u!+6VgmIIA>
zJ(7JV-4VCxUtWY-TKP(X4X&>l%ME^dCtm2cj)d659@DFb$fEU!b<;H-M}(}SP2ER0
z;u$3OUYSkX$VIYh>{l3`H;Zy#B~2E=I9*lWE$L)u9e4BPEGV4UpfSP66g{(fyqe5-
zI@t9Nbzb3<R!9Qq($vPRI*e4BR@BoF$M7H9pS3S$6U&`9ToWkD4Ts(P&`5L(81_di
zd&IE0AFtr6vIk^&Tyc&0_EO9AJ45;7oCQe3Xhvq~{Azy-l}tCqOV#?(abG>^oKVBQ
z^^K_Au)v9&2>j8mOTT8!yGr9pvyNQZmA!QH3D(A|IDD0YU;`VopNQ)fk@4Uw50t*V
zGgv)-Mno2jq^+z83bxA6PiEV&)DdK6B-2&ev)19epf$qCNntodlQ)dt3VxGio8?i-
zhEx)W>y?!rRE?pcF#+8a_ZR~bWXFhty+D?|ur;4yJ*;QeN4U?-P&Z6AcI5I(zI%Kn
zf_z<p2^&R73J?LySh)sv5=d<|YfPi74oJN<$etnG$KF6r`t6s(T@9z^H#S1^o5nHD
zJ=`)4S*!xOjNI?lHz-{77lzpbeQ?Fn$$V8ZdCDM!KjMJamE%U6J{b7XZg7t6*d^2}
z|H;*T<_UYX;H$T;i+Ap=0PT|_d!C|$P5k^E`Li41al~N<%Y?G1c;<fa)$pzD!xv{w
z({r&5%a~m|TLsY%8^&*wZ#?bNr+v~3sROWsXW_{x>?V0=d?x0lNIH0Q?&o47=2*DH
zhW3+)07B9n1yhJMSh}d_TbRUtRKDYO$jQ&+qWkz{vc|CoUGOtuUA^xOCirDh6gUbp
zA=PK&1yZ}fq<R}pMt8-Ejl(?r9upjUo?7SoT~rkqz0cm+Dti=GRqtGDyFPWhzvBD2
zP3?6DIM-f3aFdHAwkraM%)^w^@NZ(}RT7GJ$B|7WQLwn23%}!M(Rrd4J=1vo8=v>&
z3a{@u36{d!dA-bm+duA{W>a48cz$pDev86DgQHk|LU!R~$CNmMEBc{q-uG@>j7{ap
z{r*1sv*!Ghqtm=aZ1k2>fgAZT{N<#1L1klLcw@M+#|(Y(=FeKVPG+LqQOY3syjKdO
zD>bmZG9Nx9Hd&-U8C9$qNiCo7>V9+<{g%VQV)?Q$_<MKNXibYov9^=2vjG?C93&`5
z6=i45P53?)ddO#~Yi1rA`_Z~>UK1hgo31mF(Y%YW6lQSH`byq9c(tO>gk7lXIlikJ
z7%SQjpZan(X5~W}<tj&ST1L!u^@G3K*-;mde7Pn0*B;jE)(v{tC5rMrPVZ<MpceFF
zko~^kzr*FfNlWWr6FR2o%lb9t6T^G>(Io9+XVB`L<uaJbKN-iHl#*Vl)K7ax7uQb%
z8Ju97sYXwzbMvI9xdK@nUrIW7CQSo{JnKnecQY178qmj0nNiZm7R)UyhM~J1yi_T+
znyuG5i)^dQ#EbRnGVjjKaiJCUD#)v0)8Z3qUUfbwE`hzH2!j5P#O`_y)jf`y%s0w`
zqAPOJf*vm!iEC38yim>%v~P3>H&0L04sv)9{gl9RZy$}q3gbVsZZt?eQUzb^h`c#$
zL9!kyMy#n0z?-Ja=cQ$X1>Y0>*Ypy}t9e7HMBVi_A&fBNSkFNaZ5=NySDr$wRV;9j
zp9&91a|{{SkBU^jznYwe=$>9%^O1YR-kkn6%2>TVF3P*vHW>hhX`-K2ccz0Bn6-Aa
zSbwIBLgLgBF}LQf6ji(zZ6T4%Ngxo1s7MZta11mlp)m4*xUW@!f<^9UENtNxC2b3~
z+-|g>IMc2=@D}hi)>-FxNtV6tRN+^r{;N}7oM9PBD!P~TLOy3mW%uE&KUoV&J_|J-
z#41+9(GTi)>I`gXEV1}!etW>;BEyu-&KY^vyE+`bd+?o$>?bp7$;60(O7)iBJCI|x
zQ=pIYA{{b#0k-Nk2%=kgiKJB$&sh6u54y3?Lr@l2H3#q51dVI>o{m%Gs+$2`y&-iB
z9^FIQpQtShcKa%W>v^K#!W=0K!sTgB;pj^C@4E860xzy6M=n(D74(;ok%%67|0(O;
z(|rnxS2ozWCZ?6Fn{Vz|8WuoDHUyPb&jNigRz0kt&!M%b$We9)gTb>kRo3_jh`X$A
zg}%#Zwn0-sDZUA12lfoOg*EzyFKrrJi+f}RxJLAwO5V3(0j3-lxJEeoI>w2iSO_s<
z8cGCPyKnEgd=NY(5Hm47K~-u_%{qSh6oC%eN@O&x{ir>#eUH+iP;)xFabcaG;Uggu
zm*GcMWVMP+e*NQVZEti#Ysr|DC9&p`lER7&FSxy}O}T&k+kpwbc5!>PS&G!b7sGp(
z)o=JsGYIZ+CyoE;??5PGjV`OO)`5_y|Gd_MQk8oj9ds*rKF6`eH^;!>87|1&{%6tn
zr)*gWL~u$sk~Zo1c&=FfqMnj2t7x)LU#I7nVSGRYYpcG-xZ;snOQ<~GBUmGu@+dE9
z<L>$j?(8v)W_X*<adV!iRl|L&x=goba2e%zZ_c(h9T~G<3h9S~V8Um&{=B)m@=E~e
zVe=1#SBVg{tC3f0_|TCXUJ>yDd%R?;J%i8Mb@H~tH4|5b)5C1JX)h6zp)XW&v#Q)0
zm+uJjUX}SKdNa1kdsFq0dg1=Q;Ma9rwY~<p1I54Gn{i-!yth|$vX<&j%~7<Yv+wIN
z^Yts&R+Hl|rrd7lnF~O?bo?<e2v>Wbvh;H?AhdD<7?_{tuKlQ+VW!-`^Ii=uM^P1W
zM@DX9tW&(rCX=@IhkR}DkAOvF^*82hixR{h(RFHfw;CMd%z(v8xw~3RiVI5}p<Mo%
z$e|e>uL%pGYA^hHI-fsMzc4(WF`=g;TN9t=&t`dS6sJwp1?!0T#Zm=v8p|u2rSsKG
zvGn0eQ^6VPTlDSGM!fUhy-RaC=wSqApfkCDVbx=8M5)6{MK<*;Ca;@UzgTAh>9=B4
z1`S=`LD-p6_9(8A3v@niSX%(84(A@6bkDM|EK%kRR%9j>P?2kCGW_zzfJoixpDX)I
zsDksnhRRzTEoV4`qmU{5yCQi5{S*BzjK&X=GsHBn-5AYo<Q}hE>PnmNhS@GPX-gLw
zFq{+Z-+#@-;iq!e&d&;rp!5(PmFTmJ<B*Xf%Aajc-F(z!9LH->(VIwqWPxp<KCK^?
zA|2jB^;tJ;M&tOw{4Lvw?~XJU2Kt2VS>{}J0fzDo6lazQ6dw0)eD`mlG^*5c-N7C8
zxXERN$Ir)NGamH|-+da1j2ZZ_dET3`Z+=Lx4>wI)=XwKh6n~lyX}V9fEy}4{uNTi-
zOu^=0=`ZOSrhBG5_Qfan3nD?PUBlREhZM4e81MJCHG}YJ9##n%b07A{DDy75=saCL
zt>ew$fyI-j1>b1ZQ*VqcN1pYJu3-vfO)Q(ZEl~JJnP<O{OHc7>P>jGf<ucL@e-<&@
zKJ4C<9<GpzJ*?N{y)?do8VJyPB+Xr6xJ-dCko1yXIYw_aevwefkci{AR*m@e7S>ID
zcVUG%?x^NEm0h5a(4`#Y`z;Pt$KIz|d5vY8z5=|Nr3&iUuY+S!ZLLN3?q5A0g$t5>
zhdG~*c(`gmkmoaQdSDdQ+u*S{WUw4drGH9WSdd=c+RuHyjUOw9w#-L~_tGn6cx}_;
zA1=~Q7YrKy5qjfXcVP*>tn4xmT;|D#i}itmNj_$?6mNeX$En$tmF}oKCUhN(64M^g
z;_1qcX)e(CLn^YN$t5$D173o>_%id91DWvxv4n&*zDxd$?Txyh`+9z8eoP%o$@Qdo
zp4#RNulI=VS}#i5vi@`fbdpsGBn#n5Y@KN!pGY1e&e(U|V2H#;ciAb!WEyivq|P3*
zB_EO$S-hE#xMLLVM>q2bXwQpNbjyiMY9qBoiUu6BpEwzosNSQ^5H*aTQQRsIxXC08
zzs=1{_xH2xPInb)hg}f}C+DIV*o$V|6z}x5v5`|@#U@;Set*u6{MFK>0mtC=7T^3u
z=+zHIRW<m7qa1^>3uF?<zGpfLn4;mHxwh(z8DN5<9hgAPntu{NXw?vnwF$+1?HnWY
z_Pp86fN@%d^0G+Cg;QZQk3|NfmE_D8>(oCqu6wIZFEbs3m%5c{$K}8EFW+<YUdOoH
z@yU=-A9pTygiDTw)qPCaMoU$FV=*fO;vDkYE)(fexguE;&Z-UjtivJq5_~YWM^sL?
zXm!R|%+l;p#a8*oPWC>-g!}rH;|>RV-YhS2e@z|It2{!{*h6y2Yc(LqJ=;6dxT3NY
zaD{&IdtsHob09PMyM?CwsR9u3IxjiAYSzWx>zg`Fz1@eIU>@)5I=_Oa&+lfe?PYaJ
zWlODXZTfomoY6o0K(=b!NaN}1RO%8!u0A@=Z&X-|-5S*Z4NM$Gu$@}-1GoC<v6WD{
zdY53H*|7B|lDnfavwn%{nC;_vafMdjxIp9+s7=Stx3B_ZMN!=LLWhE4T-oUICbjXI
z=y*U0Al0bKVQlsa-t|sO8ZsZyD8YZ-2`QUsUSXE(#vm?ROR!*7tJht^H1|b)<n9J}
z+UP4lhc0)d+JifI%I3|%AWAxZB}>24za!jHxNEWXt^RZqSMWhyQE$krGX_#Fqwj5>
z+mU){n2Ecv#d_V$n-7Cpkz~WSP)h?Va)VnATS~0C`oan<1NDr_8rqE+pvuv3TU_X>
z*J7|jHy!_w)i|D)u-yoG>;!y2AK`$$ea=!3wPKv2<>OCL5s5`aW@(GW4><~d92a^4
zi5Ys(?pNr?b>^YUx`o8q{r&1|-`nLB+{yyjt=p9)?&rRd(`vnmk`U~V&pBt>Bc0sT
zw&eiWj%_|dQdB^M9CT3eL4gD0^KG=9^`glx(YXdj&_MprWn(CoU)lNT-4^FI*sFjI
zt^5{G&<`6Ici56n*mALWxmsUlXO*0NS8AoH#<eyhn6Y`dbJuWj3g&z<0?aEUg>{^V
zT5Dl14d94T_j>D9ksmR8{op&haQsKyCV8EiCtpOi?K~2Gt-LX)vk)+A+xilCi{)6K
zP~Efj*@ERKLTQi&sklfTXa9zDYcO~`1=m~<Q?@ST<_tdAxLLo~p{B6^*q0(^rBMXF
zXZh%tte}~O#%B_>jtO^ilXCL>8~Qv2WhL!nQ?=H)(A<yHT39dR5tUZdiTPa^8z;PD
zkHV!3mNnUqegma1K6PaB<g$zdw6%HIDS^`|`1Yc9J9Q`5-^=n1kUuoJ=;S&%|5ej+
z{b6$<Iu}d87>tFylA9TIn{n;$Q(UQtuQE6IGM)Wb-F1)7zOf?-Nk3Q4Cq$`8_9;U?
z(30R5U#LDskAd}#p?KttxcLXO-;^8)d?@_2EJ}8qm^f(=QFkYUsFkd&tH_n30l>)K
za%?p5V$bWGJ3&P4%rcj~in*$+qb~#+!&iblw3U#dXEt0WC$>CM#~@Sc1qd0*=JB@|
zZ39OF#8(8@TwBA`2})f3X|8HB*(adkeYG`86TGInW1{NOIxYSbWwY&qqRWQkfPc7W
zS`lm4c<0dBgqUg;>Bm76I(~d0dWHvBdzViq68F<J_Q2i(E)e9YxwUq^mMKxFagsWM
zB^pPjZhhKf2_n%e^b%~#_>G2e5JY>#xwB0UFPQ%U`s#<178D+MBXK6{AV8I|auX7)
z63yJJU;10Qq2)~Xg(j!~f!{%mE|L42>gZU1K(`{`fY=0%G0bYQqFMyOeJX-ucLSuS
z(*_8!xe#fwM=qs%4(~rfpquOeVPnhosA;8ZX%Q<6zuNBc^!l0SWp&SWbmP6}Md>>U
zNzZN$v@rbyWxlin*Y>+n3cp2|dY=b5d_wi9u2yHNcesosSN;g6^ce-{YKP^7yIk4u
ztCaPxOfb*OPie~Gif58pl8wuo*S>LQh6g$X0ak7&3+<sY&bSCE%wtC>$<a?$vxS>N
z3i(CpM-y^ubPD(K?|o9&(d-b|sbH^{*jmMAEwRP@qLOPdH`?uHXHsmE4bYTV31^->
z67`A!Qb2vH^vT!Wv5w=lL=lpw+;(aa!3S&uu9&}H(PtTg`^Koh$gjA-b3C3P-Frx~
zNK;w6OFAR#hBH{4;+S%n@0n@ibrjE96k9%&@aK|`QmMx}5_XwD@DXE<b5&p#!5a4o
zv^=iFtn;AF!;C^KWQ^HcVoU+(aJ}y@2W7N2?prc1U^mhwoNt>Y{Iw0$nb4-t@}W)f
z8_crhm)-8s!sWhEm7g%<X;b4dmwNZ3AqHyMT@|X7cJRHMGMiqw;!3v^?pEFznNRc$
zQy%hJm-e9G!jq~+c)($F5^Bh+SaH3%@3|W4iEU)oa}kNrqibX{PsKiWQiFG1R@+`v
z*?O***pMv|`8EKX@KS3wGi13c@4gy+YrVZ)qza9qJsAjzuaj!n(8lp*FCx|>a#qxn
z1`dJ+7{lM&_TJrg9%hZAek<{zDA38^lV296B26i>2Pq@9iqyM+1=dS@!C)<X7`r^P
z!YnhT9v_di9u7fP7clf5L;?q$(1iQ7i`@kuEUdYxkSXk9>zBn=f?Qr|Iq|U&^%KBQ
z4z04WipsgWF;*GJSc?W+`bH3)4*p%r3RA$h)4OVLV+-qGivL%})7dVHx=R6@88>on
zi*^5ol_o!2jwyx?QsR}TvnczJ@0t?|ekmOCX9Rl(Q}yL&!(Ze^AK;=3b)fFGd1w~C
z)Si87X^WaxVQb~-Hb_I(7BZ-^;D*^>-snhaQ@QHSA!{ezHO*w1&G8rje?p87RS%ug
z3`fDH&u@aHz1uL$6@3<SW~UKrS9Mt_CG$&DgY`v|&%#jyerjXVTZ=?2jl>#CBFUnw
zI~B!-XMfB#mmyO}C_F$ZO(7oJ(nLPn$K7+{Zr$%V3@vvk9|L{llsJ@+^RvsyoNHjX
zJew`Gt_`@Gip&6d)hax6v)X`o<NQTLBiu1B67%d%l7k@Zz***7APLr&x9Ti3EIey7
z@zvsR*p2pQACJ18|D!04bLS|y=l-0hqwsu@!5_77Li=Ie;&is_o~4^}D=YH442kVO
z`3BSjnSwB5pRIchw~Q)AuCv1qAd3&^cPzTP370p)2#4eVB=Cx#_pDq(tyONfuVahm
z(s>u0v!hYcqKbhy@fxQ|`7JwHnHlYaa~57qR*&|0y?;WzU^0<FV+A`wQM{tgbS+X)
zc*=K%-=8&5{q=fZ!t#<WdMGUse858U$Tv@JL8nKWiKSOy)OuiFq7$KW)!}vA2c6A&
zE?d>%ePP>B1HCQsndkAjG^Ee>>;9{9VwXTvxs2e$l-%`8#)P49QB2mE3jmo{v`Koc
zJz!*zp5S%cIJdWR4~NU}Tr%@mH+tDRnLQ{^Pk)ef`z&)(N5LVaLdKVe{|zm=+5-w<
zPKe&1<*a4kd8xF;Tr~RODR4jFshIWAk4i-`Q2v{;l8?pgynR;`QI%{BTOA-}5U|(j
zD}rK=QrcPn>6bJ_HFg*%afbU%npPP((a+YM*0JY~K;0)jqD&tK&QKB;qMUqQHpevP
zSQR7c)>$>h?0QC58+TXFH^tbBZ3>bbhy9Lnn^#z5Ig}rK`Me>w?I4ru?rqh8h260&
zo8X-)E+NUmb*v>AiHEMu>~nh<&ZNI(iKgH8S`L~}p^+85rttTA25tC3$*gd6wc0Wd
zJBK`7y`_2kFIc9XjAsPz&zC9kuv_P0U6OUC*IQy4jP&uB9<?em(GL8o_DFJfyKL*6
zSsN>9mrQxn-1t_w<ForOpAn)HZMKw2u)8TC>&U<lQ>!4Aj^cfWStHQvFN?MPN<bTN
zl0MB_)0A>|Zb)@Uo~h+5vD!&P=M*jbTL`!4;Z`txOTF&>51giM0w<=F3iYp%@h4+G
zB(~LW4HpR>KtonNEK@vPgSqvjD?z>MIn0pn0{?|hYbU=FT93|<mS);VGgBd;$e|tj
zD8gahx*b5bx77>Eil2|VG{6e9!xt`WqKl$lY+RaDXaXz=3<BAvDu_vWoZ#Ts5O9F+
zNxYKfHvW!MpA<>`H7Vz~fe3bPI{~!2(WWbJAVq0__PyyZ$rB^zM%|vwwZf_@u!pk1
zVh-iMiV_mivChWriuX2G#?%YS>lSAlh7`r{NkSwTo9W+aCK>+R^DlGEbG+lvf}u95
zn4FXNN?71AU)Ewu5iNhTtSd$LX9uS2l!mrehh_TP!q_#Aj%T&^WLxO(qqSEA%B5jw
zVfB$k1=KC~gIbA@g;E}RRR4N%FYc&wr{!VmxVk|T8)M<#{nXjhy(zjIZ6G=7BgII~
z<f!;9-Ic0Qe*wr^^Nij^9Cx@>^0=kD)rkKvlv(-(qIX=5elw$i+wNG!mIcSrMHtwn
zWu3KeKw{4SVKY^yNia&3>z%a$k{W&1u)x<;*Vw*&|6KFC`r{?`UyPgCb)lJ_BOB{Q
z#1_B$eS-r?)cAPz$`#Az2x<??0f`P-8%Wd$n9;R;jC1gxl|w!T4<iZ95jPpCV2uvh
z4Q_7_TGBp9Nv=p8wW_t-Hu7Y-AOA;2gOp2voj-=pDGl)G8mX;%7$>ptt(Q~v(sYDa
ze|QwXI0hR(TQ2q|SaY*_Ytt6v(ZFB%QssE+d%+#;&H77gvs83BjgS&m2Mv8O0YcT6
z%Se0POx<7p1GVr~I$h6?wl%~-$5qA$1(bFY7MQ1q+PRtST}dEPgx$uq8tOOiluM7Z
zi?DaZhEZb<RYS4T@mB;Hni0b<HT66*8nu}Woytmfl~sGJ2#I-=X?XuH`0PN=LW3#Z
z$p+lOA%onj4XRY<(vN6!ejdzlpZy%ks3+cxG)>KPj}he#9(0lIcAYIK-7H@sK=jHb
znJD!-VZXSNJ3LFSyEAvoQ&nBl#yQ;d>%Q9g(8XPA5Di#!>MVZO?nu+(!umOzm{^NQ
zFYp#6y^elET7oIneSTzb22lMRR*l=ZVdT_5H^g<QigVcNI~&LSZn<A=K0wTq?v8af
zn#|d{`-BsTh<da6@J&4A<FFgwQdBcRw7qBsJ_(`<Q-ha6q}Td}HP%v=27D?#t1Q+l
zx)bUJN>Ea29XZ*io<@#j0MJo+2lfI`f!nYB6iUZVJktu1wwzT@xg1mnlEeq_u|)@%
zEhXbseD}C*O)Le{qVDli&#(0gB})t_xD3$Wi%f$aL24+AVlqO@HoIKddbmmCu?)c4
z6d^VP5bPS{$6DMaG2h;Awlq)hRZupNNp%<;qksXd%-Y3W;lxi=H9#hy@IXT;ERiPT
zeS?xyoU*~c_|(QSW&36Zv0!iX6(4w4p_YG>uqIhi40n*z>s}|mOU45sga1u}qK!iI
zE-PESOMRDfV5zSF<x*$l;q>^2A#@n@QdU?k!SKfTP_i_q^b}F+XAt{*@QxqNT|<Y+
ziBo7z2>OU~CuL24fA1wp*@uQ{_PV!H0gz9oiXyC~$?t1mFgMn3()+6e2L<!uUV~_{
z+6y$YVJhOe3_|cliyeO9Y`Ar9xuQ#?=7&1T5FdH!`i761#u|5N0Pj?P?rIlF0h-p}
zY{P-JH?HpSdQ?g8)_{_}`d$7AaZ-D;lJ@5oGwp!qEcRi|mxYNvDJ!7J@Vpc?n5U7K
z`&9i+i|qVXYI%dRHX7+b4kx9S`R+XpEzja6Eic$TCv}_|JXx|Xlq@qqS3M~zCtINy
z2wCcO;Nzv$2P~~?4X>;?prm@1uU;TS?#ao~xJW_n4(O5kKTuay{g=b>Con_$;wo$6
zfP>oq@5`hid&galUn*mS7GUv;pS@}dZ!HUT-~M@t8Y`wItP@uG5fbyF;}OD%n_S8#
zWX{R!+PBt4B$a=h*lxV(!ubt0kmL~U%^_;vgD}1A{xT&vM#!I&UR|^G$G~n6*J}~o
zcmXxQQheYOQ`|X6P7ulW=&!U?5tyjD_ILC{<hYm^K~QSZU_pUL1!L1uc{axQSp8`o
z<vEhO5t60MCIjAXtoTXw-;?RLpd=ynnor}V@8v%^L#%wW9(Q<=n3aWvgbeo$yom$Y
zQWW@u<Epgd=KG<v#WTKNKl~#LIP~$YYibsIB|6>ZR#|)Zs=M@atm~`idPd5Y=Rqc7
zf3+XDI+Y1cmhC)0ioiT_fubJzMBH@REG~~?^CvHK$`Y^rw^lE7MmY1s|MC$003!l~
zdt+DVjY(ZBkyNag4-idT^8V2s@mtx+?((0<s0AK1^JR_SIIsVaI2*I4PxXSF_U125
z*)dq*n#ExX3@RqXnlFgly*!_>NNL$D3<9z=fBfb@dYD*Q?yT@NBI<2;ZPyulGt-&s
zV7aia_YX!3RtY-+THdPYf4Ga^1Da66bTc71Vk}3x^}=(2o_ie^xlUm^>GB|8F-GDU
zJ3QpS2e)nKDramjOJ`KJfi1)h9HeQ$Hr;LgMjiYYpEOh``w#6r@el7kaP0)3TCw6-
zFOx~&v%zU_z!av_$pSFC9S7x-q$<$IG1@W+9J)7g@Se^;@a01v8-0ewsravnc0vt;
zt;;45|6m*az*^!K{Hp37fSVlcM)?e2(r#j_IzPD$OEwQqtpY4i*gipWa>TzS@$S^m
zc96^G;`RMI^GRhI`72+8Q0u=mMHVb*Eh5u^Gy3)a3rBK!oa*C@Ac_9GhRDrh89?U=
ze6^v@cr^L&6k-stW5K2UtvNbi4Ez;w4)b7?;O8Onqo4@zw_54|xZa>a2pB4BcpcxB
z^OXGCo+NT}=NfPDH^<r-^Nqm5xe!|7Dy4jAHkfIhVT$x>wYsHEUZ#SsKlut`{Uyhv
zqattMto^|lo!}MazmC-_1#J2*SRnux=abd39^}CwP!Rc@t><HQbdLlHzRusGQj)$w
z?xlI~I-8I9H{!!XsD}@1lel3w?^$_nKon*_i~+pSDvOMZJSzS9n-)bD_X;H-f6`y<
zIT^iodl@VA+VgAMhxW*y-k`WNBGfpPB!rjc9$l8Irq7JK+6q|BhZr)G=9BO<(YE)r
zqAFCo+U*Q&-|^E<2zHd+?5+8MLM8Y{H1Y8;UdiZHbYi;4a9e<>mIYZIcEoJMS`q&a
zPA9c?rSgA$f$!BS3V_x=T3`Is#%v{icoKc2EgO_{-|qeedz;FHf}1h#kqn(5=E(7E
zlgqHCXG5i4=nD5=e?|l_&XN>0WrkJVHV9-4{CYLc9Z@%R{OXCckHbv{k>{%^_u5Yq
zqGWWYz)+<8u-~xgheKJW+_gH!(_d9jdOx)_R81*vxcBZFivMsbZB<*R0E();TP+uz
z<>JyFjaGf%iCFvViFKZ@*XYgcS-$~=X1ebhxqn&E7T>jz@T(%}%^ik3DOO88!NmCb
zy?45p5ld(HMBd9AT^s%ziw7^)84^FWp>Q549o<fbDe6xKuWbe_oYQ<GMX!L~mbfS`
z{4X8OQvcXFvAn$8b|O0^04vNnTW9c5^W7+RRx>Nhn4=;iBTrFoJEhv@^yDjeU=)7m
zkL;EydFE(6<o^Bpv8^GKci`d=Qs6#X2~KpM6wu;8%JOuAiDRG~jwd2D1X5R`$dq1E
zGh=?z>y()e<ND5?L)C94m#jOTpKz@jl6+!2CFzBijc~e~SiC$H|A8=Ja0<y4pr${l
z7wBh9ca@)Qy+Jq`-7v>3o1UR<otakaGB@ujeCo7864f;F3GqJAn$CB}V>hR1j@Bwt
zm+pI_FUkYodC$sDNmG|oxS;wo09Zy1_C7@-L<V7E^dJW4(5#E|#_O~Rqd$_(Wa}4}
zOV+zzq47(}N~GP#zxZ?Dw05l>yTWhoE;7h%p!K76H#wfUA!n(JBA6T9Hw?eEM$;;v
z#!a_3mf5KXy&1Xc8El2sIa&YtS}or!>LWB46fzp~3ultjJ^R^DcMu*#QMmrpN{U*I
z=1shaZUhF%<Z*n5N?<Oo6}sNzXP()h^&FR&uZG$a+b4bWo*8P5t9aa>8lrpdi3U5I
zik;!l1U|MIZfVje@Mu(rf`<!dk_P-^+{?*l?N-?3oo?w*JV-x(Uo1rL<OyeHx!iIi
z-4RIX-cMbEooF;D0iNa$xcGdh8U;J0ENi@yZ78c4xw-IC_o6rpv=(}g{p#Cw3E^W8
zR9>E9*bLbdm6bluT-asNBoZw)2e&!fDk^Q6b+z66{kI9_l*i1v%K6Y*C|MJxlC!!X
z|KaN%>nh<_PgRxdPSDi?bQ%xoA~Cw~N9G5++KAMW>l7Qj`Q<+2dU!_jW%H(X={}f7
zLRGbg>QJ3Unb=2!G&Iwppp?nI%oYS&-?;TE$!KXY*@G6?=?@zv`>ReYgP|ekeMp#i
z`?ey3=!DDHan1^H$0bVNoOwZ7Y4gZX8RrjM;G8isYB!sfWfRU!EXzpza7LEjzU)i2
zJ*yf2E-$amBemi_aq?D`>x#1}&{TLV^teeOK+tMR?>87kKyVn<yJGxX{<q@TwL&Y8
z1<j&mhPW7=DtBetzGJ7&ZlVw6S)K5(4ywCti@jTwo2XHU_{+A|0pxG!OF!~c{QPqb
zE~`zV%(ynI!c~4UXziVJOPmkoz$^3Ox+khC4pY`m7uf3&Et^sozHScHjn?ai2Th?I
zdtT%|1jTBZ=Nb;_;tU%EY{;`oE7bT^%<Si!yK&22s{Ft3YR@t=|6II`GN682JT!k#
z5U<)`KEAHMGlUT%G5%2VGAgag8h`(w-mi_#a0&?<7W5H~4}5A~Dl5x&sM6Flqzq`D
zF7D>0q8Yz*9rQuV4a-drYu#2|pQQGE!_-u@9|G=%kh5#bsM?$zwd_{lJ<LH>?rmaa
zWgV5z9#2MhS_9gVTth*kA2s7O+Y4heZp~gR#9bOarMp+{{l7MXj5XLE>jDb%JNm;v
z%)~eH4>2HwFyBS6yK}a`@`+wKFl&;T<H9d}IxuE5FDr3Ze(~BxR$qP=J_vlmxkpBS
zz<6_>PZ_bJJ>T@3KW%0zqe^f(KzQbhAm$&?grF7(r%GN&F@Q&Mk_u+{8g=_9B!|=?
zak|xuYKG7MbO^loux7_Tj<@b`Pw*x`B1+#B9{9i^=+~`U#v9>#r6@1*-uLO13QE)u
zA98-400o>JY6(i`2^v@tkLRd)<vjRuzvI%EgPeTQ!euec&@fR~Xa0bUVn1xn6L^`u
z`Fw6e+VjvpvqP=2D3*N^&eOyyA^K+O>3};|6@h5;E*`B)Dj>NpjT4xz3cN^`o$^ba
zfc?<{h7Vk0T=dfDvCkTTv$tZEm)KNVv6w<aeqw-!71%>_U*)AjAIY3edHc3RrUyuu
zE@NHdm<EI<D02B+?ewZzBM`Bk1bNj@H_=A#g)UMX5NWG!((t3`2IOjJ$1kpJZp>Ui
zM7C~yqI))%?pgd38*C`#;u6BGx+YUlA^O)UBH`wCh0CE{bV3IUePlx$?67{klf|A4
zceIz=JzQA)8iGQ&m(Qye(vJ-~`<Y-jhn-R^(2n+`ZyE)#i4j?0^8<VOyA|*A3|=4T
zbv!UK3bgkNc(r<9VJXzQE;eOyU%-xga?@{PuY@_CUA9Hq1{~U8<sJyU0g|FxZ<usf
z<tW>o7IW}@9cy+R9(erKH0u8Kb`SdH%Tt1CheTQq(zInRMi;*%r?+`mkF*5u+&^1W
z?Ug5aLiaN&c<prbnq4s!XDb^L;C%O(?$NEq@2D)3XJ%Tp2+rp##pdX1NtWAGT~rO~
z?em@P2bjk_1*ha0=mrY2f5t79%HdWoH+;Rr^OaL&R7&aWl;ynBz1m>u6{Pw_R>E}a
z;XU(GWJK%`^YO;!w<j~2?bFG7(kVkiyMZOz$BA`70o^j*4YUemnXKI1b&0^TT>R5N
zn*HU)#pQ4H{q18}A??P!t1$`7yG5z9DLee0&?`n4;g=p|7{uw$(g(DgfW@<>nGk$F
z!*@^mErV!mwpaphp;l<`NqqkwUq*~`4MU<eixR=a4S=%K8akg?ALbuj2urUTCEHbX
zJH=kf{A>J+!Te)fdw^un+)?H`%8Tzcbnfc-$3*pk$l9Yj^xofiNU^5ge9~L-wNsxy
zRN%y&>=aiuKtH}kDt0gmtzid^>}Idy3QbmKv`H_waF?JBTn&0aGMe3gX+-+WnT<1h
zXO8~t`QnXLvX(o&7Io1R)a9ppe7W3nQ{%7pvjQ*N<C&ScVSTP{^yC-riMU8_W(REb
zy6e(ALAH+Uc!YL~(Er&G_H*hrJ5NtfsXqf=t<A{Co!-Mf`@^;lJ~(W)jaQ;>aCAFZ
zsUr3DI+JG^+fG&}xgOb9;}eu?Ziyf5(H<e3O0+xlRDsvbx$#B18La||J0@dJQ9jM=
zYJb<_XZIM4SpU_YWfVpd$lq5PsiBmwmw1j&+obI)tvfQmVKchvmLD7%b-7jLONll+
z==B>U+c7tTtrM_$#yCIdLdqgNUigEGGi@4v#^^l-vg^;K!no5vDoK$$8MaqAh0^cd
zwQU~J-X?zgT+0_R`matnVS0n8$3EQyQPAbnEzER#m6jo_j*m@xq`BF2ToyEP*~oyQ
zt1CO)+Syn0yeJ80{eW(Dr?)yDKUCE(Be4e@*gE~pjhG(F?!HE*D1`uek8W2NTu8L#
zWsiB2^e0C)P{6YhGw~S3rRF<yy^HW{JYWLRV+VYHNxDmT8NW3WRDW92^=R^8tCk(O
ztu!^A66Supi|%2(#lqLj+>*s2)jJ=Q5$%z>A|||y^ny>BB;v&{thlX}GMD8)Lb#Kr
z)Y>++&Xefw-9X(J`#N-04voO4>U3|#V06=J;APKNf>O4N-E!ayJgTIK(*@eTJ>@Gj
zc(%RP{NWACdM_~IU#u8~OmM*@!|6Q~Ojy+C&~1$!G|CJyxnho&G<VFnE|%?9!CJ{R
zuCf2pW=_oZTW%$P^k~*7K<%8T%C2ZTrSyZhv%TWrY5ffvld^K)owp4z9S6@e(nlkz
zuV3FoKR`PODf}wacu}d-0BGYVynf3-D)_{D$_cOSxOhW7a*zD;RyqDcfwJ_p0;XX;
z>3H<#U7<wNsg=Sjr<W7Ga0d^GbLRo<c=1cWa%jb=$rq5v1&hbyrm@Qfh=4BS_Z&SN
zIf+7PP1mt{`f&g7)!~-mqXvfT;)v>{{>{7eM<F%S>N{f?-51!w?BoYW4DQ@0hnY%E
zo*!^}F=VJxd*v>#KAGqdSW<nDn1kv_n~dErGC96qc6nVY;(IH|`<q&AZEQdKnBzl_
zS6v0{8ov9)x9`7<Kv}r3wOdO3`Mog>@&Ia+hF4zvJp8L=l_`BM*AU<LQR79c-KCqs
zxh64}@10+U>dcs1S3GeVWcS$;dvEE3+RnP6#+skz6pYF0InIhs-ibcfm%(cyM6_c?
z>5sEy>xaqn!P^EguKxXt2bb&Pz#o5|+P^(vi}!_aN`(D0(y`_(t3kW^<?!NL`CnK0
z37nv`9S`&HX)iRfBfGw9zrP!YJ$iF*Fm@*=@0eUCK7-Jt)U83Vz3E9G$S$&z+@YB&
zDb^X>Yu_h~GNc}jI^B0ld}iBKGn$fcTK7>|zGke9q@|1Nk9Y&apW3(q1M0q`q#Ua7
zslLd|<J$k4Vgw%aZY~T^`1I3rJ63r0=Z<lilY#+;P8K3DHujp>Q(1V)j}|Qb9W@M*
zX;!iOU53*;>{5Qc;rUH6_=gf$@h-95<e&qWg=uWfHAk^}h`x=j%A3y56aC!!Z=T(M
zbS&N+Gl31ecKjPM&9yu$3SvmO_~YP=<YE~bML#Li)r9&a9B7KqclwMNdJ@8I-*NA3
z9M%+ck>6~(#gB*NDFm*6qE!_EdDl-5RosJu>+M!p=PeD6xJ+3y!YW?QMBB7WPWNi=
z9gavCm6c0U>e{$V_{7<&-LN#A+GkSE-YT}sBbea4fKMu}GU8L%$_cmDK9F42gPwqa
zWZ+<=dT9`p<oMi@)%Mno{ReZTEZ**luWR2WYLU{}9mtTm`)O|j(Q21qUNY}bnWt7`
znUC>zEVZYTa&(E+#TWDiD|PhIAwuII4d`NWTIv5|>@A?8YS;H+1tb(0LJ5H(#h^vW
zp#(*w4Z4vMhK^w<L0~|Hp+Oo2LAr--q`PzI8er&-Z+p&n;(gEWf8MheYcYGTJ$s&h
z?&rF$`@X^C{gCFcl^-j~5u0a4WW<jHP=j?YK_vl?g>6()ALVQeVdx{ajaXKGoT~h&
z`@Gc8zUX9wFD=c5PU3cRgvIpaY6&@nee~eO2VrUDYX=t48R!+e@GR*z9nXRG!rM-}
zIm1N0)X<qUN-0cQJv?6|UA8yV;dMDja=Ns9`dS}%tU-B@C(>Xt@N`xpu7N*OhSA-l
z#I&>+8!JgWvmfT)b~Bd}&6Vw9+UChHe{<zj7?<D$!$9|Xy)AdFf-^!~$SOAUf!IV@
z@S`DZP0qP#kg}74(4-ui>h5H=de<mzNAKw}-FRH$(mtvH8xu_9y&6kAx^`crgduOR
ztX(mY02ao+NRoS-k}-b}>qxxziP_6mxtVRYpBNgQv(hGds&=D%E?6WXgYs<j3cGFI
zx}}t%9v}bWg0Q%IT~@T>C>*-{Lsg>Ds`#{DX{+Xae1*jjl6Nx4vxM?!_n1xPPVZ@X
zLPEmh*^g}@hSpui;&QEurKxtI)-2+UTO^v*L<eOd?$&c)%+`~f!FB(7GdjTzR&4cB
zMWKdXP3vMo{<_A39u+hbpD=dx5|g~nM=#F#s@HjQ=_;>cBzr<~%Ic0W*z2mMzEac{
z<6HbTO{ks0NyiVlOr3@1y`%o+ZNJ8S{18)#cXLAfxdbr8)k&6RnzrRtDwPTkyVT`4
zUA~<6&0p4{Hmkf9mh)^bk!HthC&?WceGl@;5e>v5>^Qvhy*XYg;|(Us>4SBSA}BT~
zWtXO-Ws?~kxvJ%A(*MlWdgqzCg6lTIEIAuzBlPzfn7~Qs>vOtK2#-eICtl_DMNd?A
zgu<m@?&c#3<Bao(5++?5X3v&injoFyMo&gwwv3(iR7onmW9E;$&_VZU7MVDxl+CRZ
zomX|{6Mo*)Ix!!Ad~()!Vklink3FL1p*py?Wj;fPx%J%`Dlu-l#Py7{b>b_nhu4^C
zKP`i$@R(_<R*(#uu}stPMXMHR*?8dyOaBo9N|i|N5Gn~Jx3yd?v~D8DKv^^i54L?;
zMSPuI#vm(&Q~157d5H-S4U|3E0tmxPT^4e$OU7+6oq+*Iux`8Bs&j^}Y-h4JAv41I
z#bL*%*~|JaRAY4_&+F84r8`~U#}i5|7kL=H*kU95a-51y?R(Q4oP5UK2JPyK3!kx`
z7_{uB>=UgA9~JNM5PlY&Q42Ywe&i32tujnp*qPLuv@EH;ZubH`)_TWNUQAi=XU18>
zymZLQx(Pg~Wj&p^cMGJR>j>eUD<!g7c;ohh8oEheUz_hUnnQ}j!S?c>9gMb9#%tIQ
zEpfs`vQc)Qn(^eI5%ZBqt(W{M-P;;BZK&%l%Z&G^PM2ST*2oPXMEAj|SDQ+o9K^La
zji$eoKY%dM#I?9E?2&Z6>s8-y%VuwXEO|etIYWF*fB~NnJpZ+#qGwXX*ij=)jU1RZ
zV(gH}sXR)={F(#xfk4P`=UwQCB>J{y0TFn99h$RpTEMMq45wsvWGvSc#0xpBDYOpR
zJ)XEZnNuy+o_d)$YQ<lsdBLi3br?HJJDGDyp6TTV#NxRur9C=6W>&dZ2&U|Mrho_y
z0pYpa!X+7Du9WsgZ7=6erkfpchs4@6Ru6ka$WC&>zS9Q`66KiDupBx02-LeLS8(mP
z#h)L?Rquya>9ic)8rBvDvZy*`f7U!pmwNr}W-K&K|BSSdDvEx3*`6U8?vixV4%i~_
z6bMrb?^fsXy_J^J{K?w<JWi5#L<D)@e*R2sMEimJ)tKp=LdXFPFra3h&7HLh+%mJz
zX)WmP&<>yvIpBZ#|9l|ifa)e%qD)hW@>i&&E_vo>4Xgrh5W^E2xG!^ov@c>dB-K_S
z0I^EiU#l>v=qqRlb~Ru>HfFHkMSaA|Z0jddnopMeBz<V-Sz6|1f3&qugsyqzRR8^S
z{}s#xVT}jEf3#=IR00{5`}pVM^vi$VnblwqCA4E`tPWO2I#F&ZhRV{5Ysk)&v(6j|
z@p2$+GbNEiC<CO^Ung<q^@dR{l9Nb*=c^XP@{@MR(9AvYvB-P#p&<EKqO*Wcsp4k_
z)9WSY0pI^JMfF><m%i8Zb0R2=GVc<ulc5dC#(`7+N2I$3!f=ghMU~1Q!s{ZQ_O%Vm
zw#!IFnwUBHk5~YILLdKpDM@x+)<n=7+$d7Lu4pB=Gwth!dSH{Z%RVpN*V^jq-Wimu
z=^>@PeDlvX#-CsGQJM+-O;pC2KVT!k!Aqe;kQppbIopi^`$))mL>4<{H_b!obi)6U
zbNkO<|HplxqEGC=K0s*-N$tRxf<B<RS{ZB_#pVsk*1|%Z(kk{uX^)Zr@BaIHM>0v)
ze+AshoMElfnTRn`2N2ZQ&N>Y2%GAu-?d#fHfhn*rlM(sP)6_qQ!QVfm_<a1Zu{5)-
z@hk!1BG!cm3)o}tlOB?-CW$vT3^<QQ&s$MG2on0svG7swdTTLID_<Dh<u9(jcrxU?
zoSd8z7yFFy4HKsAsvE8xHqx_9$)XIHClvplPW=D)>}`+J6MG;)Od8ETWlUt_wpW5M
zM>@iW;|0Zcee=F+rNs*&9SKkW_#UA!qDU&Pu%agIp`dh?c?ywN?hD1nt*Xu%uRxwT
zOD-SGs(v=#JBT{Qmp10sSF3*U3Y2^2;q-mGz{*Yk3`?<gz8D^^<}#O6U$wx~(RcH7
ziBt}nra5=Li{?otOgkN|2E^8x)1f2gUmRwdwY1k7gkP&A<c&Lt7dH36YZX72W=2N6
zUq306L?x!K$bC+-lxE9osE_T8q2d~V+6*W%3fbo+XRj!I8taH*2p?z!IWq3+AT7VG
zz-`3zTbtF?9HJPs(x=qcD{9p%oWgy7EgaBH{L-l{*}m9y(A_85Yv%6QOo;7_W>AV5
z_}0<^jj=9H+&Us$(F!j00bYlkV*T84RMXy4=rFjzCCq#FGQL!0>cZ)4!Dzaq7;S<W
zd4Qr{ahEr@SG!mKQ%Pmp`J`+iJW~6^Qu&?y;Z3jfB^OMY=&EP(e2H6^sDAJl6L?4r
zRnIVVVP@i01<A-JGNj_yz^A=^9dydnF4A_;L9EuqYDxZ9TH1CE>(pHg-_ZcZ-N?%1
zsk%k~YcX_8bTVe=Scx`&!>w7THf@$<x@>0j`3jrD2K$a8_vZ?$@wx7fP5x<to`bRu
zsINU8*x}@}Lybx&#%W^lnXW)!uDeB95{8l9qL>wp2xkA?LUVUpJaEv6o|@8~ukhsc
z+s3X57@KI6=DYH_s^eMeN~qZA!X!trYDXT$(FiVfy~ZwkX4O%KcnTe-^W!LBY+qpN
zjr=W%hiI1-9mbSNM!E$%emWo-y)H#SXM4NduS~w{GmtgrGU+d%I}>3xon;II9HrT;
zZLEwPl994wzHrL3O@k@DLn`&;7*Ut4NGHsQ93YJ~=}VCsD7Q04H??<lMNU^8nC9Ro
zDaJhs%hRp$FFeRi!KXOfn&x=;@ZnPx%Ir)I9IN6=7C=F77(YzkS(z0GRZ~y1v=+50
zjx*L&e_GhxAxHiGQYrjZ44xrU{sWI(E_jG>1L`v`t=>VJ(LU!<*Uz|m_9>hqyf@m{
z6b%9lqlfLu-1kl%rB!fp*A}vsRJW2F>h{k`-NE}@jD5rRL0d)3y-6y3Y+YT-u644b
zAL7D{AGLTPN^D`&Df+fcl$BHb$-M31#UqXEkE=!HY1ZLG%SU(Lh!baVJbXZyda+$A
zVX0%G;{I%~^Iq!OJ1ILoj(fshZ?D^{s=U^D<{)Qvk@De{?%xY&GYFN)S%F)tynYr@
z7~Xd-`}^sWue~on4Iq8O=ij!yGCyIxldeSc8KnO(YCgve7*OEI+c86LDlP;b^jM~s
z*p|`vxQcK-OdTH%56$t>x-D9bRe!{irLpzcR{q0Ytbpbsf+QWG_L69e+~i)~!0BXh
zyG6$)!QYAnc&}c!w^j*n${qHABWb8^GnRd8w6HtueJlEQZqQ_hgkV){o>~2i3$IIW
z&_L#5VnK5=m0;GfyQhY`;)_TskGz#h#>Om#m*VQ!TtUAU#EZy9Na{-E&3x{lAe)rd
zi_T1tMS_FaS<GuSc>O!A_{x4;IjfVs6rud6@bj4cT5*2PhlNYIS_pCT!1t&1<w6*1
zD8EO_QqitkGi4qP)?h0MRno0TDz9J;|2f0@!x#98*}FVk0|XzqgWjZy7j}P#BUd**
zlYr(M_U1NZ_jS|@CrpTfmBW0gT&j$!KizXxUaPpY(=amPxDfwx82W;-?Y0?4Y~I#c
z<)l1qi1lbBWwjt`0GEHsc1zxHhp77pP~!o>8Yf(-I__IeSuOXCUYZQq{b+ubBs`F|
z$S7q}7#`~WBMF1@YvK37dzrFK`2SNrQCWR!Kc#>T*h24+EQ-0>n1L}(vld1ooq+gC
zP_rbPKy>v0;mCn3S!kf*)L=TAazJuwmnqD^F<d9@%APD|hc{f5rdow<W+1K`g{|*_
z0I$2}d%c}Nyj)JfX~&4P^z@2iJ_Q^$$$$LW(o=k7y8UQqfw%LsOZFJWWs}(L>$|=H
z{P5;AuXYWtI>HpBg~+hUR6!D(r27G`a1ZiFKNoM3rGigh1r51rik+L6N~Szf_dC6U
zsp*6>a?c`6eft<64Y7j2<&ldm1IuJ{K7Q~>o_2MfsR0E%kKB^gPTo}TSLWK7#hO*^
z9*U0M1A|ns#XSP5b>WPpQF3Cv@2Stkilpng+d<S+(%H|FR8nUi>Q`&#m(r$=H;sT+
zYAC1>0pZo^QSoqHSzZ_|0w}It4_CB6{1(00D*G$aE}kPMQbpU`m^=BmDA&U_Y&(N?
zE^o68eTRe)*gTYZawm%}D$}e25w%Aw0TL@x6Yju*HD0IKIMb_Pmk9j@)1Udl-}7*Y
z-9D>%Dw8RDGVrN0a@vgWG+qw@@Gv)FVvDzO+k{7@ec_9CTjYER7?M|wj1(#Ea+lih
zYp3igcpPFv>PQ}qOj&10$%DWp_dy6yrH+`}o_Pn{&-+HV%a8yXjRO!dH}}EhK)I|m
z?czqx*nKX4*bp-u*5qTvo-wA#6b;~FS4-(Rhgc;}@jX`xt7>1Q&zz~h-VWUI+Ww^L
zBJ2;Cogt*&<x^8rk16N6`N2k_;$(|JY|&X_KU}_<ft|N0W=A*k2`Lv8`&uiPWEr-r
zCG?0}9rn5fI{_DVmW+hgTZubBZo^kdu-N;K+t`dYe$%edQp?c}9?zXy1h_)t`+d>_
zK%~`*gAr{EUU&aKaaIH_gjBE*00)CR1pb8#7Iv>QUJv^uJjhmS8@-ap$SF63;yyEv
z+bha8OOp1(+~b?kF8Qqd8aeqg>Etxd>!<kb?c!s6kEcJU>{>aLXS|=tDGf0TLvjkz
zezFPXC1ixkJ{4EJgt*@vf;rmlFeesgOLZMYKR0iR<&b*8Ao3$es0l?_tv?JM6%@nP
zD_O+RY~)&g-2(}Rn<{oW41X%TIcd^z$#QQ7KTPOqE`pSyBbtrK6Suic_bmla@ZF4w
ztd(5@!?-63+v210^IGfJ4z;AEgtj90I|Ju_&k*s)AnGtTCh53)uF04i2s-(}U+|4u
zwVWyE;~yeZX<;^}-k&rFgc`K_By5FL^Z70Lv5#JXpl^QX4;<RCGoTuss$w$gw2z9f
zThJ61yqZ7pqlF_05ADmQ{O+|6q=lVzr}lYpzP7#uee9@cfs^=;K;7n0LmUFH<L{NJ
zSu393%zhEhLDbRH`B{D;O{%F4s+Ku*_Z~bM(_*6d4q-9(&dD|5W|iKz!aD)-%}#d#
z3NU-+l(`dJ!rA90^SiX3Kfs$N2-cFXO<V&NN#9rC-e#MA2&daVzczov;M=LX;j<2T
zF)e}-$G$(J584Kt^j2}b`%unPUpspRudq#1xSAcgW4df)+$&T+yZ6C!%=_9m>_}0B
zM+c4cHTjGs8&aJ<^D-6_%^rz2?qP2BI9&<ITiFHGwmjx5A^UwM`Vb)b4uYX%&XJBq
z^pScq`18tGP);fOqMmT7l71^rH(XOf6;zSlmlnH1nRHV1r+!*Yi%_~r-#%7oy!1P}
z>>Ug)EfTN(X2e064dc%yYOT+he=S~;I0s?%WjVRw>)%fzBcp}DnPDLu4f>*?B{gSh
z+PA#C?cMZz94(gh-PTeME(7Djy?FJ)rAv{l_YQB<zwN(ge-aSIxDa@3lBQJTWL>ql
zkX{3F*icaI7qB2RWQ*UxeKd7!UR*&C^lp26(M{oAmgRF1wDZ;^2SePc#JL<g=7E^U
zf#aPo5Qy|AmtR-!(PcdP@REH`vX3I)5;3XL!Z&Qx*^Uf+ZrY_5E@3nYNPjXVE+=Ld
z-e|E4-*`jiceuO}CZJgDr<sQBdSlH+eiPL=|JowF{3)d2j>BR`ImZu{*yyPH)7r;D
zI~Kx$;dfPyr_@xx%4Tkd&ak?>?>R5skwfBL?P~h%4E!jRO_%+)3wr-ZJ!Wh@x%AhY
zGLw~;qst9ViRFStPbVtCj}yYHI2#e~`i_eC6F$MkVG`9+U%#B=t=*mjtGb(`#Agq(
z#da%dQL_bQ8COk>EDQ#zh80$e72earXX&~{R~1QN@egX;x5yE%UZvaZDD}dP0~IFK
zABbr!o|sN&t-y~0Rw}P*NTQahPtdG~LR06RSW%k$x#!7-ZI?bC1K(1CSA5Msa!PiS
zX-IusqjZkiytVkUaU>^k;CmyrpqBHGh-*Yc*S%Bn-vu0!%_-Km9+LY@RSSL^`%+DY
zF(g}5tVR{Rlpbq_E4+1sz{arXI{i4o(L&sJR)UtpSyAszOvbZT?9UE2dw7LrW0R7&
zZ``<HKj%jcUp8U;x6@|*jx-Z%eptRnovvSygy&4_kwO3D<?tHjZS2q0pep{}sXjF|
zQ+y7_t>m+xkB-l+a!?xh-aE34q>(U2p66C8mCP28=-u2bc&4K`>yjA9-G*xN8w|Zt
z9|`Fnj7)KU8+rS)D;4`}Xlkd#+Fiv{!tOhEYvvLybt>BB<rZ@wA7kC^0O`!{{lErt
zA86ty2_qv*u7dgH8(g9CE9GA#)tOza_I$Os<gn>CceD0^oQ_{ZLs{p%2S+kru5G4Y
zTrS@}F+$YJ%?~Q+#;tU+QkKC+yfWF8Y6UG{_SyNVIc)ZI4^(_bNmf4Q*Yp$?94@w&
zVgD7=Cc&e#6n}~7h07mGd8J#w26;HtEa~;`TAb0fAtgBLWZ!N$JU?5|ft_#MIVEe+
zX1eIj3MsNz-WF@DNxg&~cJ{Wq0X<6}Fbc&iHj;0VOVE_+y^e#qopUSLq)we<$-C*O
zI<J!Ie$|Ld&0U=sgx>y%Dvfzpu>C3+OkjOgZcy>Wa#nY6P~Rnj>#Qjm&JZT~{_RT5
z?)QFCh@kJ;DQ+_Hp+a#Rfs!^C?(6Dge9w}KVE4+>?<OSLWy<1A%1H|sDYrpWc^+;s
z-=lPyT0x^vNtl_LO?j86QOO<&>sG}+3N0u8zH2dD!&s90@?&*q&Q;c`J&z<M%dO&l
z9qf_=ax6L`?I=LX(5aHuGk*n+TAn!y7#%H%$$uOITUOt2Pk}Ltjb3b#pS@G4Gl^Cr
z+;q^%Tr5+?q#3`lvDP<v65(ccL}<nFBy=i8<I<`BbKh$H=`<rr_!P?(>LoWe`Nt6<
z79mSlMAwmcwaJ*t@#NZVpyFS}Y4&PmQ;_p@E2*V+iGbC|O~@7}3u!)>pEr{AMPypD
zh|Me7q5|Km;(z0hW*=g$OV_3)Jmp<1-W+O?8eSG4r5BndCRv=p_rLkfoeekWMeto=
zkPwj2oLxSeGYrU9IY5gATflPb%5u5OR3}?)zYX^SyEIqNA9iV@d!gas6qX}en?cYn
z@S}@3o}Kg5^Q~Xp13yhNGbwYZsw<r9ruZID4U&TkEsI{5yLyeD=&myrJ$8s8wx;I3
z*{u=5qN_!6b3KE=Msu-=Yv*wurh_+x%y-#_?t!kh%Pslrvw*&uyhO3S<R?x>6$H0T
zX37%nU!ZJNR}Y?YmDUiv`owA@<F?sX4OLw7nF%V@ZF*y7v&LF8ae8YRaUeLu!Qs;J
zRJzeCo^xVG<8y~UPy}Xc*JaNG+bb3HGND)b{>W(_ki+n#Vyn=yr>C}pTX{?T9+y=s
z>Ste_eXra=Mq-_|Rdf<289R0_!;zbq<0|<bG|k2h61zKD)V9GT_n6N~PD3-G*a1ZX
zNCe${(=}yMFGD<yH%Tk1y~<avHn<ei?Y=h*)cMtE)EUT%3g?f~->GS8DRB`vjJ#xE
zik%#3jLFaGc|8Yn(`fwM<zG~6TTZ;O>V+IjjJe<Gf{ixZY(iXvJ2?^14m~V_oo@Z2
zpdEgAF7><&-p$iNle%<)X7A+@d4PpZF{9TR#1p#cEVb7!EK;7>3%C0*q$tbaz4fM`
zDO*QpJ9iw(`by|%0jO?6QR-thpR-fb115B6;zJKD1Sn|tbRzF@NwI|BJK4o<ryGw(
zYzQ}yH*E9r$3$QII~{t}7v*n%?2_vYEq>j^$X!$Y_&L4{J(Jwd3`n>j5rkqhAK!MU
z*|tsSl4oRLt#n3B6KMnJY;=sebp)2Q{ib|V#Z1YL!P-=ookrYq&h8B+(S30L_yTz6
z@DyxsKdNG#^3IT7&8&0UxJ*rko+x)bo{jd#{r0vz@vW6O9)1aR#^cS%{zTxnFSL6P
zRHvm;4Aoyj0)aCzb)+FfrRUOiMFy=ZwA0g9XS`P`VP&qBIwL&iU_J+rTWcexDezW7
z;_OKlsx9+}D@Ug?T2FlT!B$wCE!K>*7c)od`#N>T?~k=_0n;*^eoZyoBc)@%#RvJt
zlFfFW;-zl^X(0`xuVMgVo74sd3uPs>U~i090a+1Nb+VFTsBD~`4M~8B^$wmtZ(yL!
zL7C5??V9ae)`#S3fjq_pWC}?TO(3zrqips3=!Q=O@=$a=lhx3n01iQ`WH6aQ{4n7!
zkz8M>T1L6$dt<BOyA2u{Q3c)Ww_Sp*a%xL7p@$LvhpX9o(HBdn%-U&QpGg_MH;KGo
zEuhZNU3<W#mBewB=&B|&f~=lYx!iBDswmO_0Y6}fuKotoEX*jZE~t)yz}8L%P>FRk
z(WyQIpdZ*!j6XCyLUd7{;~;19XZ~OvsxbKdZN*Tuo?gGi!9-w;IF=LCCB~!<n#hxW
zcKephDc9NEwjhqzOGT<H9pkw8@H?X1^C2S@ZYo}%bkD3pHagB;C~d}ZY{o^J$KT5o
z8r4$6O1!&-4@Z%o)S~SDrVi%BE1Xx=7<T7E7p})A#i!wDs|!QxUF|C@g_QF@Z@~`=
z7P&PaM8HjjS0-n0iFW<q!L^0f1qxL=H|4BXc^>4B6-s-GTOxEMtcq`j`Sp;o(~8_4
zq_Y%#H7T&t(fcg{qugVil~l@@xmxo^<Y%mU3d`7fO|Z#?px9D_e9yc73G^f^Swwky
zJ73IxIHh#`ARz<P`YHjl@tx~oQSs`Nlj)@xHwJ5_t>FBawrR$t_Q;0GeI1FkI*;dN
z%TGdM)Eq}0Ji-%1AMB@UrDRf;FQq?ge{}x3XCo<BZwqnnO+`boyV9xL?)*@;4_@nR
zI7<-9N)2?VP@z<F=2j|_+4N-=9LAQPx5d%~R|=<V4Y|cdQF4hnqKKN*sVL~Rh87#O
z_s@x_txjI!;l{Em>$;?Vp1Ewq9(s)1cb4edZx)a|8e74r(5H)Zy$U~f`3`>|n7~w5
zef%v2>X!#W735Bx*@d~A%{l{bdN_ij5!kfMJPJs%Z*4AK8cGtA4#LY-b~UZr=+I{d
z5~4>Owj-V<uq9ht-s32iZGVHVVR>Mqm_K!;_7zfVUYjuKfOH)4=;c-jO|Oc3cytNK
zRMH1TgvVVXFwWTU<essgqvPzfLuHb2?B3eAUn^?Ar<Dk6Z^a3<qc|xp#ZeVgS8{<#
z7}3Z{LvNK@?(9H?!L!q*7^MLOeWH8k!d#!zRYx?mBKy5#2ED~3pxzNx6(65abG{QC
zc0a$m3wVj1{(z?Ewx_oq2Rsir$jT=7JJh5qjGmnyEc8YfpPotdNuNyWb;Q*8>33>Q
zAAnP*9^axk0QWyz{sD@jJ^+W&NS&R)C)G~cIhOzwu{QTsqTQLx^3%}K5$9;{>7Fob
zumnl`b}8B`lnvx@3KW)>6a``Mw-`=(?`q*{bApMqk^At94qf#1)L{M8%%y!;TA*#4
z)O8?>c`H|L_j390b(~`*1g5&^a3P`Z6nb@%BFPS#V%ODLJxaBgpF}#;Ag0`Zu?c^-
z(f@6C{h;1GIKR|V!o=m;<S>i~l2Mp69I6%RF!r49Rkp31W?)7!@wRS@Rnn+cTLXdv
zD7Z#;Q6TgxXNx@p1d(M2^saW3M>T2>kX*;lZd?Jtlz5FS=b*zyRFub(U;L@utHB@S
zo%~^dQD99ZlyqQi$PkYhvo-}El5KRmfh{xyRcG)3ieWJ43#Dt?7e5S!LShj}ld%FD
z5VUx`^)5UtY)*kn`>U~!pl7jZ_j?qaPckRt-x(nKWV{y{hoKdlvK`;|K6w!zVbXls
ze;R)W?+1%W3`iFjEfQcii8|a4VhhOu=woZ>Te<?+qwL(n^R>$OA(vMB1^P4RwQuz<
z%CxK!gSA^8#czB%lAqf4*>MdKFjz6<KY5+;6PxVme}1rF<hm9=Uq3P_V8eWr-~cz6
z=Go3|kY0@6T-%+UGBEqL<8k)<&bsP~;(}5H(1kqM-2ClpimzTqir!D61%x%@%!#6%
z!k_N9B~#sS3j?i9C~k$!>D0{)+3mJfY3>dpeQKIBRx7}AnXP5oYc|E%$|BEycxVFq
z>6<&70ZtZ)EJsPyn%87TI+aB<)i$SoPWgyA+|PQ+s0biA@yepQm)rePUn|NQ<slWS
z#wY#F{46&Q9*F*sRTi#6!%p_*4XnSz_oFe!vjR>Vu#;{thedDUhNNP_WO3$iDoCh{
z#jut&jn|L!y*H?<qL=xH42vsfA+pf{{ugJ@O@G*1GDKqM$?wYobu{>F@3j@ww7VSl
zS&&5w5L~+`fA-8HfEL{35Dcc{sq>If-b#+3eL#|WBH)pETP{;}*|THibC_8he~`}$
zs%R<Q%8p<-Shg6`n)C?NJCQx*gUv0^mj%ScHpWhw)dydQc1MNp?Ve`clx^&R=b;^x
z_8l%J?<aFwx?m&Go>Y*oURP-Z(A<R=4=2icKg4@f|1{Ew{t-;q3F=88``y|Rl}<4Z
zh>(~%FLKCYXB)U?v680efUY$-LKZ!lKQ-~K^5eAQ1nuu(VU=;(2{luS^y&(ZSVO;^
zVztdf3o@TpkV?7Nh^M)36wkV0ZZy4+`TcY8$`ZPlIiRu`?PSEeR@=NQbEAC$QC&tn
z&PhHsY;J=M*K93VF|*Y_@2*`q<iIuTd_Ll{pd7{iX3!*i!aeB2p%_8@tB86&876KX
zo_t~!2n4NYg&+jDXQHiWeB@cTHtM%?!zajk7`nsI;w0A^LMEhFjlou8xEs=n)b(7`
zZ&Oiq)Ev!ltR#EY?(KY-q~$kl%X*ic;0`ND?J}9EcI`<k@jB_$PlHa*^4!fA$)a;9
zfqcrULf^M{1^97GkFtM}<6od^SA>yRzMko61Q4dQ#w|@HCQ-XA+^)t=ecg81MuSJx
z@iNWy(X~S;S_y%-bCe0ng=P2Tmza(!HK;HrzN>EqUA>g{@r}OH5%c1A1cWyWwU(HX
z$JLgjeVnb+r~S3)_tf;EQKDt?rh0jfR^zV`!mH%(2pt4*s;5xd5vo5gFIT@UA>MuK
zRx#Z%Ejbal$i^8p@F*DiLE+OwC5E=kV|*Zz)^u1B8Buix%AT7syX95-v|AV*mqqQB
zU$&X%M(1Ut$?@slM2-Ritot1lTXb_b5t{t%8O+4Wujgr*Zm-jqb`oaMINSBSv(U?B
z-SB93QNH#c;ySb==|Ot=4LH@JUgogDBn7!a%Y)Eb-G0^l!45sMU%4g=>;oAdZn>-)
zZ;7Xq+!#iW;7)9l`O-O#BLZ~kE7~SjYh}<PX=Ih5kxyEgT;R#2uYl!H&QDJHQ3o+W
zS&>yc<VMmXl9Hs#BA&rAp`#Ijc106O*@G|n%@ws=qS^x3@$V5xs<o4mM)L0*#pq5a
zanb7Q!!n5{@U)UBYq(eNu>HFrjr5h%q;rVbBx{v=Ubl)fLT`a63+*_J;yKMSX9yav
zA)k6|Z~qq0W($(pbZ|F2eY1PO!6Tm@qO$>c3(gvSWzyAyqJn!Id>HNd$vU#@w!3FC
zou^xbmGpj-S9EmWb~0~@B8qMz`!Twuye#I2O@wYm#ekG7lqMAfI9^&(!4>EpyU152
zIkaTeIrV$W<Q(0%EWW3W5;+=CYi~cjRwA9=bI|AUTU{q<g*Pz3&sLg!HThbvwE1TY
zj1~`ua)J0d6K(}K+`_W|vO#}+I4$Br7%An7(m;}=ayGkWk6JDqJhhH@mH~V0s|v%m
zQx*&*JkMbjK<+6Zc9EaP)qD^SJ}EWjz~TC^d|t)!T{GI3nJpiu6D;j0b1MCb3c5eg
zm@~X>70AYIds<CYrb&XE`)M6ejbE$q7i<vVAb3Uk)ZJ)U%E_u&<fBegJYeGT_K9SM
zK-CCBEn$>^iHomAFbqJw*B%Q>;fUj9v5a7}^@zN8mY9Dn;5Jb_6NSw4y}#8AbMG<+
zxcY-I0)M_O#gx_ouGx4P_I=LE6|d9=kQHkQX3d77Z2xuIq0aV+KwSKf%<_LS)Y~kx
zUo=7e4D%v68uvN)8o)SJfro9zKBCR8?wpJr%wHe@tpoD~){QlkuJjk#-GOZ(tO}6Z
z|CRUlet<_W2oKoa_7Sw3@pYrz3B&JaFr7JQ!}SKw?6)Cc{6of0m40sWEC1ms@h@q|
zKRJDVrwZ5J$$@aikFBx$yoB3iXvL3$cIc7r?3rDIHL4R;iN90^FvUtjnjI;ZnDgRO
zNSSA3;AvHRkrj~5F!TV~3kD5Y*VtU`nuhq5zm^7kSltPaj9d);*hacD<6p)HVK1M2
zedqXNrVZdk!tw>QUIN?uCAc%QzWCQwOOS-fIH82FR9L?8oUd--8UcqIh-)@RkdB5>
z{9>m?>4X;1z;oGu@Jat9mj3jCjET&KvW4YWH5!`Wx>qi!3U=)dCGe>ZJX}__Inbcx
z%oXS8y!USy-9OYDe^7Nu-uNwgcqWSH1gn$&h^P-qZ!u)BXhRfmg@qK*HZDI$-rKG0
z)Dq|ZZ*rW!_1PmrA>&a47R|i^#5F*av&dZ8#8lZ-kd*RFyxCozAL+)a3ijV^Gd|(W
zk7)DycgXqw{Cpi}hpeB^RIC}cmnLZAO1Q}zaKt{sn)h}u?l{D0ub`E}r-ta@fu)nC
zXLJ9bhtHoBA|LS{5jJn4f#`@|TaWhz-jhUIE4%H5xcI^kV$pF)%wm-;L=+p-M&gZ!
z4L_dUIRD(uFY_18-%9QMWVr85m2=jR)V;=qY5#maRe*S(yMuH*GhlFC7>b{PEX^q*
z?Rg3Jm*s5iQZZ2zqNeQE|N8`@{P>Z-A%_U7@ys1%Xvb75ogm1^DBsM?7|lz0m`fV4
zcPLdkY;i&^%lhA6be$rTDU|SfZF%|FP6#4}bcX>yY+A<UNMrw{bhUPZAP;=VWUWjl
zF7RB5<?7$9+CPkqe+(Era@$B(!hNz?=A5SN89Zl7v|>5RoxPS7Y#4CDn^Pr`Nx4jQ
zlt_3P^vYlqSl!Kf!T0sE)pFD1W4Kj2-wHN;zQd8`b#>`;a;t0V%+O8)NY^I=KUiN1
z5t(bURx6!0tpf0!U_dUKDvfwQR$w?#>13&YIf=4y$?NP%6g^uO?x(axYL$L?cTKv^
z^CC^^6TY`oU41K~*9Mznf>1wC(BO;Th{DE()k@sjOih)UUOuLmpOuvXN4Bclwq_xr
z!Grhd)2LhuT<@&1@zVp0$y}qKeG`eG%=9ZQt+*2N{%5uz=gGLImI;@^qIqT5!7b?U
z%JvV%_{Dl}+#co>9*T|;%$Siyu{qlK<mAN1d9Wf1?`Y9_y3!SzrM8e|zcD<`oR7sh
z@+`;LOqS(3uJ$!BI5i?LSv>dz8Qt-Moqx*;yVI8{oo=`AtM+`Hdha>q%eKx=%Bd#9
z)lYMk$QGluprz$y5%l<Rw}?UgHH*O?!DhpHqseA3UWnj*DDK{-yZ`!%c9hBU*4)J1
z$L|Bu($Wgv88N90*J^N%eud6pMU3>j2;W(24hv)l)@qd0YAuEMRsi$%ku(#zzT;}S
z<a>lvCZLov1w>i|f;Sg|2t<_Yg(WbKpo6{wXw&-AK=QTPE-EgqMMtgv>n9B$&)MXP
zxQ7HFaHL6Rbh|N9jJ;Rl%DoS?lV5kKW!js>P~zv~gJUsMT>$|y4odCZKYgWJIzCZq
zxpaAkjREi-Q3<kS&r^#AWOMT6en!vJHERS3oj_Z!*QJAZtUD$bRT)9!OkOYD;WFde
zN<L!OBeB=TKTzx8rcR2T9RU_+%8+I%z~qz$i7f{BlC9~(=5AEXf96>H7Q}rsGRX1b
z#$!IR7qjN2nyP@)@A-C9&m}RVxQ_VQ2LE`4L&o{CU|ryGALqt3rTPG%<7++6-meX$
zlefT!NcuPWWf`M>zRBn)w_ETbygD7NbFM{A8BMJAe_zVV&b!&s8fA+E<ot~J@`YHl
z*1cj+%zpW+nZMc1z`zmH{@T{Q*6OWFOaj7?LDV@Cu#KPJ6|j0>-ue=hA?^HqBKw{2
zVV3oi0hfj<Y%OM=VA{#d#H4-PESYOm&n;K<)E6}RPJaVP5gH04iG71la+mEm@2ZLM
za&}6YyY76qK)^tslQ_^!#?<u3AazqkVnhV%)%l8q*q+~u7nq>*jEqhmuM>G71ut?T
zbl>ah$ZNMA7bNtpX86w9X)#2{pE5I7AZWzPUlMuw6kP2H0C2x04Hlz$iBm3U55qdY
z#-r2bke?s)IVYU(v-<N`4_mUFx89X@XH8NEji_f&^cUO)Y^oeQ3dICKwMyshIvigB
zu9RtMTL@`IJ_>53U=bS#16gdHE4={b{WS^y9akVVGA<aZdaL4b3Q1qTH-S4_lXPtI
z`Qm*g(Nu*@4~#aN!hPxxRd=Cy_vwel5F-tup?C38GXAkvJ~w1;6Ygw_H+*8?cT7o!
z%@eInqVk{Htw~=4>%cOv_hw@~kE+Bg9x;+IQ#XCNxIC(J@r2ZiQb@3EZ{v-cmSFOC
zwIOz|=yL@=Aq1OUA#BBl3!di-jJF^mdDXielo{8vY|~1IO~<0@t}d`RQp9>=p3W<Y
zE+UO_`XUQ8L}PR$66bTE8veJ;0ux6xr=iD}>*K{4Z$!7EfVlKQ?#FWor_+z=m92Vj
zJPK6~XRqHUt(~Ls+#Low5y(m$c8jOF&o#ierrzb+X=^}JP0tq(K2~y%z&%=z!j>TF
zR?Z>W{CDqveWA6Vu*eVw*@t;8cYO`nYqs$^)6Nh&Gb&Ws?|GvQrOLhfLSS<2@#&I!
zqk69=BHp@E4wwe_aS2HGXEc8S%Rn{{6~?K#R%1!IdE!H{xksV-T9gDuG+^Lm5??p-
z(WIPYhK!L3X5tCzx`$dn%hOJi1rzSP<TnJ{ZHeS0aD^#l-@RV#|HO6oeTHHVzN6aq
z!Zm!J+iBn5+-%s1v&^%rCT0z!HqQp!Z}UUcYldkp0yEaPpPT{R#_*7CFoY~KSfGgv
zkA29PA4UQOBLoz#&y)Eh)&OR?i*fJT>*t@2hB5hd;J0^2X__ZAHuicYV)%@I;Z?hD
zfByljBD=tYLM<F_7cE8Ilw!(Il%~CXk%PxvLkKNcuQFdQXyvg0&M=hU>V^?}ZKu$b
zx>Z+pyd`k33{n4H1%`EXf8}pwSfUF#6!WkBL3EIbcl4?x_sp#awX3BR;Jo3~Pu)a^
zgvl=sy;06x`YtA(l^<M7<L~<n-ATN1-;;lClY{@T<%`TgGz#rmwGe7lDjC|+RHZ>;
z^XNN|sXqait!*LJ4tPSLn=AXQ2Aq2}RbuhR3??VkT)&Yk3`~+4f1q@FvhU3Fhr@@V
zfA4{J(>Bq-jvNpS2vK*GlsNm_eg7szJvVslJp+jDiy?&4i>PxAEs@<6PCqz-dg+xn
zYxUAJ{s_$=$aL-4?%MUMr5JrGV$D6^UuDo+4hWE9ykaq2-p9Y=r<z}@tDz<3k>QAA
zyx|xXjouBvR8N?_a@-TS7a{a(%{%(TgtM|AFUSh++LBD*Dh2In8zr3fF_LN^_pf#5
zbN_06ky19f0jL1%{WZMRIsBLFn^YZ5=SpR>?|QG7Y368qY*nl*0;!1|tGD?=?&q%K
zO`(m|Zk@6O<bU?_MEZ?*yDfJ_aomtrW`G7cZyeU>YkTmy6Qp_}41IFEJWIaPV<u4o
zcG!$62Cf<rs6Q%ic5O08li!R#GueYra3>3~bFJCKMv9TR3EFIA{wA{ZsN}2PI5j`Z
z)4H6kBY4Rrzh}_1;&M!0Rf1sNb^$o#LqgN{b*SdFK#)`CMo`PENATJ>>%X^k|52<k
zVD3GVuHVU#HDhF8gpfZU6VGh(h516~RgaLkkqt5TL@G_yz)llQ*IX)>7K)q+4HT>#
zW#&w-6;dtqkNO%G(R|T$UQ3S|k#WjtdY+O6_2;9z+Ks6b%J(z^UmyE@oKkrCMZM5M
zHs%^Qdfa315HJ7nd@Jkb7#mq`_x1%o_H<BLVtS{eDW19<y(_vkW~DsIQ4L1!tnua0
zRU3L87AFhmcWR5o$Ra<E9>u!ZFex=zGU_eDG}QESve20R5bP!jP1WV?)4pW!R30cn
znLz`N>(#~4QrV>Stqrm>qwBY2pBh|nx#)K_rjn}2I>}b-FyZu{8uc;G>LLyEnV39x
zTBv(O&WxmJkQH|hTS6+>i8fS9fPH^o@;NbJ#|_b3H|v7$QM6Dz^W|bLiO&#|acgcW
zZoq>rlIXT3F;CZWhK2CF1w09_8TLW2*~J9r$_nCViCFjh>q5uF<D{LR`9~}`q5h+l
zd=(VnB!iq6G<ky6U{F5%%TE&R(hpG%n??z4#6i;8qBvYyC4^O%vm~Y<wRLOd@^lR%
z8B6{zUxO<Mc)M;B&y%tzcx;xACZx6+O_S~c9*M<0A{+%$3Y>u9r)TyO<#};>W1cqC
z4Mz`cyag<x%<RRjPA3vqdlFk|@H=@wYiZbnnwo#a_Qk1H;Tb{s6+DAcntUUb-OTm1
z8k=Q`CLd6O3{w{$_Bv1{9Yd|vPSQ+T`oy57?F(pA(LA(5|9qahr!S?okxs)&`sXFo
z&!f<|xcl2d%eQpKc-fX37VlGKrhZ>I{Y^YgLX5`zrzeyXT#O@%DY9UiX4ht^F%++_
z`|rcIE4geo{dL|J5Pqzy&ur9v%b1Q~wSy^G4RwA{lGo+QyZlAGhnm#T=;-KWLf_Ri
zJ==yG*Ne)Rc_D~N-s@b4KV7ghTju^^gdZup@}6?q)w~<t7TF465XEV+V{C@Mdi9Da
z#Cx4Q6C=>n#B)@>N;5)eJjbnHTMZ|$$BD{Y6Ue?PQq7>6Xj%1WG6!qYXT5b9pnaaz
zQF!8k)YNr#bq#qC?5fE$H0o5>dWhQ@C+_Sr9Ys`kx}M!b7jZ6*RN^Y>R{8ehtQRoL
ze%6!EtJj@I?PJjr1#dQjZm7I{_z@lHoG*1_HE8_kg$YM<{9D)=i35q#`cV5r(m5g}
za{+oK6U_TdTO2*8S|WDL{KBm3VlfGEO<HBHw%oKk&e*8D#P(UM-WT0BPY>cV9?7-=
zTUF-pi}>f5py%@WQ{=pYfK_2aD1<u_9}tqR9Vu%@i8*HK-fgj@(eL1;+}L65Xm-{9
zMn912ZsNQl(-Xv)$;-*N|HbLWM2W=$v5nD!A9SW#lZr=A2a~zo^09C|L*XmMkZaxn
z$>?{IA(ME+*PJk0Lmb2E%RqJa9q$aXJk{n32_OTvLl0eZe<P8kZ6oYQxw;3CcKfmI
zY<<1Zo-~5gNk(I_0W-jF)<c}n^sMW6XW>Q!c_SUgVf+1LAqf!#F)c;v?TByWLUGU$
zApLnOt6Oi9SdaC5WfK{pkd67}Z}a>drIqA^eWf#b$Vvc)#Xj&D%2e(DoV2}mIPK49
zNh1ww4j?Cu0FEw1><O(-A1|4fe~lNJ$aht<cpy_Lgb1eGur=Xvaq9|ffo>%pqb=28
zA53#{jq}&7=k7RGkAK2?#tB}x<ma@ky83c??U$avAkV3$v*)vv_xfE`9xN?JW0dE5
zC1*sZ%BJO5PR*j`wTwA&Urfql0mDW-*Q05d#LE8B_@|c9dy^gP_i`0<yR@a4UdInR
zU(teE#gAt{)$3TpXmC?!F8XqelxZL1Yy{B;o)+hH19l{JP_&-c1AAq;6i<qmjzQb2
zY*OX`gOU_J3DR-24aN6@@7Xp|tf_&bGYNLukRr1+l0k{rela0p*hRu(OUM|&#qAOI
zMVsQ!caUC=)uN)#8|HHFw7z-pGJ_^=`tJzz`(FVz9qvIYzpsFdS<JFx3il*&V*mNM
z`^jGN)rPwjk|_ytIA&bdVe$oUU~q7$RpPRcKjf*ehQfrIKVtxm+Uk0CzVlXaY+u%6
zd_FP;24V@{R2$nGsgFfxW}Kt?CS@+)7RBPA{uNByxOb8w0d2dT=Yx6gM_b)byl_g#
zO~=+*k&t;EOR_HDq#_~Q^x7bn7dDxS+^xGhs|&eC%)@=Y-OyyFRKJPVi+=31{x(Co
zFHcw0%=&i19&fd(kKpE3`2uN1FF~~JgMi_09>~p!Qh6q&1>CT1C=LD(?$fAJr;RP+
zLR(Js4W63)aD@aRzSV9pN3V&ncjZQq6r`u4BiwDP;y$6o>8<0wN3ydENQr1_Jy?U?
z&Bm$QD@ktFDLBNN0c9;J3Bh-t+An`0V*5o_f5gvz*5bi<L<)nVy{<02!wYr1yt|0;
z2xUGLPi#q`J<m3GJ2>)%Y$%P}=vS$aNi0E;xT5WnWZn}SLC>o~#;9+7_#CSajNiYl
zhOO>oT`zIiRPN!}t=GIY#i?;^Hn#Ao5+#<R#%Pyqh7RQ=(tD3`4H$z$L*h#VRoQV^
z8My>-43gvHF#&F~v>#^UBO)lbFG&<v;L|`1q+zkWxG9$E<$iy%-D+aJB(k4V`6g~l
zdqJOs0z`NdaIt=#k&mdoI7?`Mi6JE01%h)oKU8(IY~DC!DaW5n4aW4HJ_zgJ&2>Mf
zhR|D&7p31Ph0r(DP*Pqn*x(z^$%q}EPDF164Ua~1plzzjy*;V?^L8G)ugpuOj@q#1
zpQqYoGLAk))Dhi#b8uh|RhzspyJXLEpDg52b2XK%YVNlx{_e3cB~C=o^BX;;C#iYd
zO360TG<l6dmqz579uD3-YIE$KSfvvw%y>bTr(>>_w?jj?nVDqg_;Kzn<;)Ix$lhQ0
zOGzqH0$y_YO}#O0)zT`hLO~jF^&z}?E}giA40alb;}G6vw?(^KduqQRjG^fD%(YLZ
z9{(pK_OF{NXrku$V^Z&#>NV!(coYN=-n{UsIzYBE5KGv^Io(Kwe9Rm9*A8pGl(rDe
zbYo@UQS=?X-Iub}OVW3n;gqwAp@P>L<tZ=2Oc}Ey<o_#V1>jKLH*vCl#vm0zQqzrO
zlYG~auEW~S&6BNS`y}&L3<pfa{9!W#x#0f=L1c@20P>#ZYL+fX+^-=zegK3O(WdW^
z3`GSRliT<|fz4<qxXuA))xTQePoU^OE|>7;nZHeL3y_T{8pzTxQf`Dz<9YZpZ)kfi
zdYglo8FzSxj86(nphEu>&>Ct!v%h?zr=vr^?GHrpkpjyvHVrg;paPH+p&(Z>8=soM
z3-&33vW|ZsX8$LQ_WPzJ0PtCp$iQHA@j`&VoQw<Q#P1MPOXMIvpf7<s!gG{Rwl-`3
zlMkLuU-b&qqMf~dGWIt(R~vuLX1+EzUcF|iVSsD*yXRlR+LD0xW561FhqR8M6vMOX
z!2OplD-RulrI6>*{=Dn;A{|Xu)9WNNkkP-ySKmq_W75*t5O^}q0Y?HQ!E<~K)6rS=
z1Tr3gvjDZByGlk&ykKqMk=p(Lt?#m`T3k^uWV>m%)doCAx};SE4@SA5+A~m40s!Qm
z?&g0v0_O1Mq2Dyvz8+Nt^V@)r*gIJBX?G<<1^Z_p>$zZ#PwB&ECKYUd4WrJ&Mx@OF
z2o>uBP!MB<B|<r@BqwBL_XfxXq{pgP3uW|NG&@`W2b|qo29Ga{)7P1D6*}$fj9Min
z7nkw_j7nAT%)tZXJ^vxQd{%}fi$7FMg#qUlHFqQc5e@#tx#$Kk#8*|$n?QKJxySF@
zLLaHu01EF6i7CLl;L&J<&mX=D%mfu(oIo-(v<nXFkoFY>x%wKCVY!eIp3Q?`7RZQd
z4<67txjDmrn|*)i-;^vowLG1N%8(u31cx4BpSin7fa{m#XkJu80zIv$b52(*pR@?D
z1Fo%SC?&2(#*2Hv(>sg)W9$#z_Ld1)<0af(zHXzpYt0Ncsv<fw(fTC=;|%NVU_s_;
zPivsupO!A<ApXr$bhepodqAE?SnogxE)?ALm0$LU!q@qL<GtnX2m$CsLaYI7=uZ_r
zhy!RIC&Gi{RNN*JNL0ZSDX^h7V#Ph-GgbqkDeTKU_MJGIY&Ef3cGocR#UFtEr*hXW
zy5%C+iDXXq_Z=%P4kvMeabePaRCndkim5g0O|su@zuyT(O|xT0^FfQQi(#_AAw=M2
za@(-F{-%49`)<1={5Sjvm?!qXXw6;%jvtEvYe+@hD*b1e-aC%{_jt-dNPR>xL%T%5
z7KGH))S@inzOcpObk{{-c^mvL9$75H^#%6F**nDM?Tt&&aWJaS(<^>vH5=RmfZYv!
z!T^Sq<cJwj1cDVVel<%98`byH9m&yLfX%YjY8IOgRJ%IR@)~?Bme;Lxw2P*}-|gb>
zbp+!~x$kuk0G6!l$x@8T`SDJOfrM#SY#an{<oO@kht1Z9GN7}&dsr3Pfhh6@rU6@Q
z;D!c**JkIXynJtH(sZX+b1b#k?gH+uI~(L?^Wu$vWF9j)y)%+MwX7?ar~uDGV&YE=
zdB%VxA7W4k5C9*yx0GaIn2}t-?tKIp-;qJwm2GnVOvu75>DHVpz{X<+fZ>ccKO9zi
zytDjC8P;LrbwD3^3*rA^!~%3rz2ddI@DHOM-9MMghnhrZ@Z4ZzU(IcB#AIM;+TxVk
z<j4XNKVzR7F2#~o3cEj*kqbvaP0YWJkAssl5<s|h00^AzH~Zl0nYKAqF<5lWZPp!k
z@B52j`|7>9RGX1HFE7n%SYfWc+#efD66fhNCUP*AY*JAHp@I~0?_wHYMFwtZ%o{%w
zi++F<`X|!<N0#uz=X!u5q0fjQXMG{`&d3V>g%4S{!Bf5c>^BU`AK7i0UqdxCdN3&t
z+27mSTLPdO;?4np@hA{_@#n2Z(g_ej3xSxYH{aPb!dEHiq-k9sGVnhFwtpCx-gnuq
zwT2(fxGD37xC3b1o4w!8ZQD7meS(0$rxN|?50_~t^|9#bkVnyg6N#)@d3=l>y!~7G
zpI1+BE!J5e769Y@?GOZkn2a;!<TUt*YK3a8P@QZ(479YfK(Mw|aIsyuTk6b~6Z`Lz
z-k0s8_$tWjSlVo06eMxZTW`?dbK|jLqwhx*B;LNZGzn$bIz%b8|1o^u+!b&?z-w9`
zBNL7OSzfLY9v*HL^&dt`roeArQ$kC@Q8t)tk~xo+)D)*Sa0fV>xssI?ZiF$qlC4l3
zC>FRpT9EjIfs={vJzi`k4=gwLL`5fe;;u&PF7H`bSoq9AdqglflHD{mm%zk#Vh?A4
zzzPgB;$;~<o`hOoSD-mNUO;vNS8Oyh_>C9ab4^P#ZrCWZB-a<*<+C`yy$93u>pXkP
zkA9O1u6xVE5kp!Gf8XeD9qawNb`AGHPDbkOzcIFwPQSHlWFyQ)Re+K`1@P9V^EnD7
zIxI7cY}giV!&0s0DiI!&VRi}~|4jA1jjoS;_=Y}%f*3kj;b8U~OMJgR^z-+&k&=}J
z0PJQSyNm5gjAgo2&bw9U3nlC7onI;L+a0}aZMHHO-@dU_0HDDV07piXGKjPR%L<po
zX+Lstqqx_3T~dk|xi^@6`6QDx??1;MQS;K$Qk2w3L?-xAd3;|;uw)6M!P2uePi!F9
zf#AM`3~cd}VW8t)mtfe;$iorQ*gr%HNFgQKn5ogWx3{Oycior2$Vo|&Jj9~00Xrjg
zrPX9Re5%kODlR}@R7TbPAG<D$;w7*s0f!XG;5iEe;FRH8Zrv!-xC}))`Wn7OFkz{7
z71K~eAD}e!M@af1*}@sAKT^?7FH=0u4t<oLG&Pq92t&<h{7L9uVP|TjzgH;z$6S9=
zZx<*?&LEF^04iko2a4eX0fbe=EVY4qWirB)7r8kRU$6eWSp5e*jf3~rB_D9l(Luc>
z+!Z({nOBHKK!6xfCWXGTHGxL~(qd#A<S(lIa`pZfD_W>&Ha3=Yj=_{gbOd^Qw^{RU
zH2VhYjQE!0ttyNp{r@7HIO!^oou6tNEpK}1j{uGr?o2(bVs95w%r<05-j3Kd5Z3LF
z`_rF?!Eakv=(-sVy^ORD4>z}S^fHOfd==3a4Fv&k<^f*f>q@zko1on%JKbjEWbmhL
z`A-}C?@JXarkQ3J!p-IXZ<_pya<2vMDqc_qwVU66o8c~z_EKzH#T9;MOJdw~eDgis
zHM1-7BNcBb%YK~3pZQ^mIU{f}=;wLIFSXP!xp|zJH5|YrCtiK*`@je3@*LYkewXKu
Y{ZgMGU74R|M;L&>)78&qol`;+04|-&TL1t6

literal 0
HcmV?d00001


From 8d45b3c7899703b5d6a2de8fba897d7b1f7ff5a2 Mon Sep 17 00:00:00 2001
From: Deepak Majeti <deepak.majeti@ibm.com>
Date: Fri, 23 Aug 2024 10:48:04 -0700
Subject: [PATCH 18/24] Set CRC32 checksum algorithm for S3 multipart upload
 (#10801)

Summary:
The default algorithm used is MD5. However, MD5 is not supported with
fips and can cause a SIGSEGV. Set CRC32 instead which is a standard for
checksum computation and is not restricted by fips.
crc32 is also faster than md5.

Internally at IBM, we hit the following SIGSEGV

```
0x0000000000000000 in ?? ()
Missing separate debuginfos, use: dnf debuginfo-install openssl-fips-provider-3.0.7-2.el9.x86_64 xz-libs-5.2.5-8.el9_0.x86_64
(gdb) bt
#0  0x0000000000000000 in ?? ()
https://github.com/facebookincubator/velox/issues/1  0x0000000004e5f89b in Aws::Utils::Crypto::MD5OpenSSLImpl::Calculate(std::istream&) ()
https://github.com/facebookincubator/velox/issues/2  0x0000000004efd298 in Aws::Utils::Crypto::MD5::Calculate(std::istream&) ()
https://github.com/facebookincubator/velox/issues/3  0x0000000004ef71b9 in Aws::Utils::HashingUtils::CalculateMD5(std::iostream&) ()
https://github.com/facebookincubator/velox/issues/4  0x0000000004e8ebe8 in Aws::Client::AWSClient::AddChecksumToRequest(std::shared_ptr<Aws::Http::HttpRequest> const&, Aws::AmazonWebServiceRequest const&) const ()
https://github.com/facebookincubator/velox/issues/5  0x0000000004e8ed15 in Aws::Client::AWSClient::BuildHttpRequest(Aws::AmazonWebServiceRequest const&, std::shared_ptr<Aws::Http::HttpRequest> const&) const ()
https://github.com/facebookincubator/velox/issues/6  0x0000000004e977f9 in Aws::Client::AWSClient::AttemptOneRequest(std::shared_ptr<Aws::Http::HttpRequest> const&, Aws::AmazonWebServiceRequest const&, char const*, char const*, char const*) const ()
https://github.com/facebookincubator/velox/issues/7  0x0000000004e9e1c0 in Aws::Client::AWSClient::AttemptExhaustively(Aws::Http::URI const&, Aws::AmazonWebServiceRequest const&, Aws::Http::HttpMethod, char const*, char const*, char const*) const ()
https://github.com/facebookincubator/velox/issues/8  0x0000000004ea15e8 in Aws::Client::AWSXMLClient::MakeRequest(Aws::Http::URI const&, Aws::AmazonWebServiceRequest const&, Aws::Http::HttpMethod, char const*, char const*, char const*) const ()
https://github.com/facebookincubator/velox/issues/9  0x0000000004ea1f70 in Aws::Client::AWSXMLClient::MakeRequest(Aws::AmazonWebServiceRequest const&, Aws::Endpoint::AWSEndpoint const&, Aws::Http::HttpMethod, char const*, char const*, char const*) const ()
https://github.com/facebookincubator/velox/issues/10 0x0000000004de0933 in Aws::S3::S3Client::UploadPart(Aws::S3::Model::UploadPartRequest const&) const::{lambda()https://github.com/facebookincubator/velox/issues/1}::operator()() const ()
https://github.com/facebookincubator/velox/issues/11 0x0000000004de0b8c in std::_Function_handler<Aws::Utils::Outcome<Aws::S3::Model::UploadPartResult, Aws::S3::S3Error> (), Aws::S3::S3Client::UploadPart(Aws::S3::Model::UploadPartRequest const&) const::{lambda()https://github.com/facebookincubator/velox/issues/1}>::_M_invoke(std::_Any_data const&) ()
https://github.com/facebookincubator/velox/issues/12 0x0000000004e19317 in Aws::Utils::Outcome<Aws::S3::Model::UploadPartResult, Aws::S3::S3Error> smithy::components::tracing::TracingUtils::MakeCallWithTiming<Aws::Utils::Outcome<Aws::S3::Model::UploadPartResult, Aws::S3::S3Error> >(std::function<Aws::Utils::Outcome<Aws::S3::Model::UploadPartResult, Aws::S3::S3Error> ()>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, smithy::components::tracing::Meter const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) ()
https://github.com/facebookincubator/velox/issues/13 0x0000000004d7cdcf in Aws::S3::S3Client::UploadPart(Aws::S3::Model::UploadPartRequest const&) const ()
https://github.com/facebookincubator/velox/issues/14 0x0000000004ca4aa6 in facebook::velox::filesystems::S3WriteFile::Impl::uploadPart (this=0x7fffec2f09a0, part=..., isLast=true)
    at /root/velox/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp:380
```

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10801

Reviewed By: amitkdutta

Differential Revision: D61671574

Pulled By: kgpai

fbshipit-source-id: 34c7b777b3fde0659ef74c4fbfd93740fdfa3f7c
---
 velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
index 08a4261703f97..77e59f0097ee3 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
@@ -377,6 +377,10 @@ class S3WriteFile::Impl {
       request.SetContentLength(part.size());
       request.SetBody(
           std::make_shared<StringViewStream>(part.data(), part.size()));
+      // The default algorithm used is MD5. However, MD5 is not supported with
+      // fips and can cause a SIGSEGV. Set CRC32 instead which is a standard for
+      // checksum computation and is not restricted by fips.
+      request.SetChecksumAlgorithm(Aws::S3::Model::ChecksumAlgorithm::CRC32);
       auto outcome = client_->UploadPart(request);
       VELOX_CHECK_AWS_OUTCOME(outcome, "Failed to upload", bucket_, key_);
       // Append ETag and part number for this uploaded part.

From 3d10ccfc1706c45305d776b545a8f4ad0656d5a8 Mon Sep 17 00:00:00 2001
From: Ke <ke.404notfound@gmail.com>
Date: Fri, 23 Aug 2024 21:27:22 -0700
Subject: [PATCH 19/24] Make processConfigs function pure virtual (#10827)

Summary:
to enforce every data format implement its own processConfigs functions

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10827

Reviewed By: xiaoxmeng

Differential Revision: D61743118

Pulled By: kewang1024

fbshipit-source-id: aa1d0b2ea12deaf5b2c2f2ee16827bd6c5a73f38
---
 velox/dwio/common/Options.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/velox/dwio/common/Options.h b/velox/dwio/common/Options.h
index a695e30b45b97..31a6fe0ccc91b 100644
--- a/velox/dwio/common/Options.h
+++ b/velox/dwio/common/Options.h
@@ -622,7 +622,7 @@ struct WriterOptions {
   // process format-specific session and connector configs.
   virtual void processConfigs(
       const config::ConfigBase& connectorConfig,
-      const config::ConfigBase& session) {};
+      const config::ConfigBase& session) = 0;
 
   virtual ~WriterOptions() = default;
 };

From d33cdb2512052b1bc131908be0a7d26ad240d89d Mon Sep 17 00:00:00 2001
From: Jia Ke <ke.a.jia@intel.com>
Date: Fri, 23 Aug 2024 22:40:39 -0700
Subject: [PATCH 20/24] Add RowsStreamingWindowBuild to avoid OOM in Window
 operator (#9025)

Summary:
Unlike `StreamingWindowBuild`, `RowLevelStreamingWindowBuild ` in this PR is capable of processing window functions as rows arrive within a single partition, without the need to wait for the entire partition to be ready. This approach can significantly reduce memory usage, especially when a single partition contains a large amount of data. It is particularly suited for optimizing `rank `and `row_number `functions, as well as aggregate window functions with a default frame.

The detailed discussions is [here](https://github.com/facebookincubator/velox/discussions/8975). The design doc is [here](https://docs.google.com/document/d/17ONSJHK8XP5Lixm8XBl01RMNl4ntpixiVFe693ahw6k/edit?usp=sharing).

Pull Request resolved: https://github.com/facebookincubator/velox/pull/9025

Test Plan: Run through 10hrs fuzzer testing

Reviewed By: kagamiori

Differential Revision: D61473798

Pulled By: xiaoxmeng

fbshipit-source-id: 569a752770395330c48a3521bd5421eb89f5623d
---
 velox/exec/AggregateWindow.cpp                |   1 +
 velox/exec/CMakeLists.txt                     |   3 +-
 ....cpp => PartitionStreamingWindowBuild.cpp} |  17 +-
 ...uild.h => PartitionStreamingWindowBuild.h} |  14 +-
 velox/exec/RowsStreamingWindowBuild.cpp       |  93 +++++++
 velox/exec/RowsStreamingWindowBuild.h         |  82 ++++++
 velox/exec/SortWindowBuild.cpp                |   6 +-
 velox/exec/SortWindowBuild.h                  |   2 +-
 velox/exec/Window.cpp                         |  74 ++++-
 velox/exec/Window.h                           |   7 +-
 velox/exec/WindowBuild.h                      |   9 +-
 velox/exec/WindowFunction.cpp                 |  13 +-
 velox/exec/WindowFunction.h                   |  27 ++
 velox/exec/WindowPartition.cpp                | 135 +++++++--
 velox/exec/WindowPartition.h                  |  90 +++++-
 velox/exec/tests/PlanBuilderTest.cpp          |   6 +-
 velox/exec/tests/PlanNodeToStringTest.cpp     |   6 +-
 .../exec/tests/WindowFunctionRegistryTest.cpp |   6 +-
 velox/exec/tests/WindowTest.cpp               | 258 ++++++++++++++++++
 velox/functions/lib/window/NthValue.cpp       |   1 +
 velox/functions/lib/window/Ntile.cpp          |   1 +
 velox/functions/lib/window/Rank.cpp           |  24 +-
 velox/functions/lib/window/RowNumber.cpp      |   1 +
 velox/functions/prestosql/window/CumeDist.cpp |   1 +
 .../prestosql/window/FirstLastValue.cpp       |   1 +
 velox/functions/prestosql/window/LeadLag.cpp  |   2 +
 26 files changed, 815 insertions(+), 65 deletions(-)
 rename velox/exec/{StreamingWindowBuild.cpp => PartitionStreamingWindowBuild.cpp} (86%)
 rename velox/exec/{StreamingWindowBuild.h => PartitionStreamingWindowBuild.h} (84%)
 create mode 100644 velox/exec/RowsStreamingWindowBuild.cpp
 create mode 100644 velox/exec/RowsStreamingWindowBuild.h

diff --git a/velox/exec/AggregateWindow.cpp b/velox/exec/AggregateWindow.cpp
index cb32bd0779c3c..2bdad5342c6e6 100644
--- a/velox/exec/AggregateWindow.cpp
+++ b/velox/exec/AggregateWindow.cpp
@@ -410,6 +410,7 @@ void registerAggregateWindowFunction(const std::string& name) {
     exec::registerWindowFunction(
         name,
         std::move(signatures),
+        {exec::WindowFunction::ProcessMode::kRows, true},
         [name](
             const std::vector<exec::WindowFunctionArg>& args,
             const TypePtr& resultType,
diff --git a/velox/exec/CMakeLists.txt b/velox/exec/CMakeLists.txt
index c68a9af02ea59..48b63d0872df8 100644
--- a/velox/exec/CMakeLists.txt
+++ b/velox/exec/CMakeLists.txt
@@ -59,9 +59,11 @@ velox_add_library(
   OutputBufferManager.cpp
   PartitionedOutput.cpp
   PartitionFunction.cpp
+  PartitionStreamingWindowBuild.cpp
   PlanNodeStats.cpp
   PrefixSort.cpp
   ProbeOperatorState.cpp
+  RowsStreamingWindowBuild.cpp
   RowContainer.cpp
   RowNumber.cpp
   SortBuffer.cpp
@@ -71,7 +73,6 @@ velox_add_library(
   SpillFile.cpp
   Spiller.cpp
   StreamingAggregation.cpp
-  StreamingWindowBuild.cpp
   Strings.cpp
   TableScan.cpp
   TableWriteMerge.cpp
diff --git a/velox/exec/StreamingWindowBuild.cpp b/velox/exec/PartitionStreamingWindowBuild.cpp
similarity index 86%
rename from velox/exec/StreamingWindowBuild.cpp
rename to velox/exec/PartitionStreamingWindowBuild.cpp
index 2d855867ebd0e..f8deecf991946 100644
--- a/velox/exec/StreamingWindowBuild.cpp
+++ b/velox/exec/PartitionStreamingWindowBuild.cpp
@@ -14,24 +14,24 @@
  * limitations under the License.
  */
 
-#include "velox/exec/StreamingWindowBuild.h"
+#include "velox/exec/PartitionStreamingWindowBuild.h"
 
 namespace facebook::velox::exec {
 
-StreamingWindowBuild::StreamingWindowBuild(
+PartitionStreamingWindowBuild::PartitionStreamingWindowBuild(
     const std::shared_ptr<const core::WindowNode>& windowNode,
     velox::memory::MemoryPool* pool,
     const common::SpillConfig* spillConfig,
     tsan_atomic<bool>* nonReclaimableSection)
     : WindowBuild(windowNode, pool, spillConfig, nonReclaimableSection) {}
 
-void StreamingWindowBuild::buildNextPartition() {
+void PartitionStreamingWindowBuild::buildNextPartition() {
   partitionStartRows_.push_back(sortedRows_.size());
   sortedRows_.insert(sortedRows_.end(), inputRows_.begin(), inputRows_.end());
   inputRows_.clear();
 }
 
-void StreamingWindowBuild::addInput(RowVectorPtr input) {
+void PartitionStreamingWindowBuild::addInput(RowVectorPtr input) {
   for (auto i = 0; i < inputChannels_.size(); ++i) {
     decodedInputVectors_[i].decode(*input->childAt(inputChannels_[i]));
   }
@@ -53,14 +53,15 @@ void StreamingWindowBuild::addInput(RowVectorPtr input) {
   }
 }
 
-void StreamingWindowBuild::noMoreInput() {
+void PartitionStreamingWindowBuild::noMoreInput() {
   buildNextPartition();
 
   // Help for last partition related calculations.
   partitionStartRows_.push_back(sortedRows_.size());
 }
 
-std::unique_ptr<WindowPartition> StreamingWindowBuild::nextPartition() {
+std::shared_ptr<WindowPartition>
+PartitionStreamingWindowBuild::nextPartition() {
   VELOX_CHECK_GT(
       partitionStartRows_.size(), 0, "No window partitions available")
 
@@ -91,11 +92,11 @@ std::unique_ptr<WindowPartition> StreamingWindowBuild::nextPartition() {
       sortedRows_.data() + partitionStartRows_[currentPartition_],
       partitionSize);
 
-  return std::make_unique<WindowPartition>(
+  return std::make_shared<WindowPartition>(
       data_.get(), partition, inversedInputChannels_, sortKeyInfo_);
 }
 
-bool StreamingWindowBuild::hasNextPartition() {
+bool PartitionStreamingWindowBuild::hasNextPartition() {
   return partitionStartRows_.size() > 0 &&
       currentPartition_ < int(partitionStartRows_.size() - 2);
 }
diff --git a/velox/exec/StreamingWindowBuild.h b/velox/exec/PartitionStreamingWindowBuild.h
similarity index 84%
rename from velox/exec/StreamingWindowBuild.h
rename to velox/exec/PartitionStreamingWindowBuild.h
index a9c2e2abf4733..bb5cb352d24fc 100644
--- a/velox/exec/StreamingWindowBuild.h
+++ b/velox/exec/PartitionStreamingWindowBuild.h
@@ -20,13 +20,13 @@
 
 namespace facebook::velox::exec {
 
-/// The StreamingWindowBuild is used when the input data is already sorted by
-/// {partition keys + order by keys}. The logic identifies partition changes
-/// when receiving input rows and splits out WindowPartitions for the Window
-/// operator to process.
-class StreamingWindowBuild : public WindowBuild {
+/// The PartitionStreamingWindowBuild is used when the input data is already
+/// sorted by {partition keys + order by keys}. The logic identifies partition
+/// changes when receiving input rows and splits out WindowPartitions for the
+/// Window operator to process.
+class PartitionStreamingWindowBuild : public WindowBuild {
  public:
-  StreamingWindowBuild(
+  PartitionStreamingWindowBuild(
       const std::shared_ptr<const core::WindowNode>& windowNode,
       velox::memory::MemoryPool* pool,
       const common::SpillConfig* spillConfig,
@@ -46,7 +46,7 @@ class StreamingWindowBuild : public WindowBuild {
 
   bool hasNextPartition() override;
 
-  std::unique_ptr<WindowPartition> nextPartition() override;
+  std::shared_ptr<WindowPartition> nextPartition() override;
 
   bool needsInput() override {
     // No partitions are available or the currentPartition is the last available
diff --git a/velox/exec/RowsStreamingWindowBuild.cpp b/velox/exec/RowsStreamingWindowBuild.cpp
new file mode 100644
index 0000000000000..81d4a4f8d00ae
--- /dev/null
+++ b/velox/exec/RowsStreamingWindowBuild.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/RowsStreamingWindowBuild.h"
+#include "velox/common/testutil/TestValue.h"
+
+namespace facebook::velox::exec {
+
+RowsStreamingWindowBuild::RowsStreamingWindowBuild(
+    const std::shared_ptr<const core::WindowNode>& windowNode,
+    velox::memory::MemoryPool* pool,
+    const common::SpillConfig* spillConfig,
+    tsan_atomic<bool>* nonReclaimableSection)
+    : WindowBuild(windowNode, pool, spillConfig, nonReclaimableSection) {
+  velox::common::testutil::TestValue::adjust(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      this);
+}
+
+void RowsStreamingWindowBuild::addPartitionInputs(bool finished) {
+  if (inputRows_.empty()) {
+    return;
+  }
+
+  if (windowPartitions_.size() <= inputPartition_) {
+    windowPartitions_.push_back(std::make_shared<WindowPartition>(
+        data_.get(), inversedInputChannels_, sortKeyInfo_));
+  }
+
+  windowPartitions_[inputPartition_]->addRows(inputRows_);
+
+  if (finished) {
+    windowPartitions_[inputPartition_]->setComplete();
+    ++inputPartition_;
+  }
+
+  inputRows_.clear();
+}
+
+void RowsStreamingWindowBuild::addInput(RowVectorPtr input) {
+  for (auto i = 0; i < inputChannels_.size(); ++i) {
+    decodedInputVectors_[i].decode(*input->childAt(inputChannels_[i]));
+  }
+
+  for (auto row = 0; row < input->size(); ++row) {
+    char* newRow = data_->newRow();
+
+    for (auto col = 0; col < input->childrenSize(); ++col) {
+      data_->store(decodedInputVectors_[col], row, newRow, col);
+    }
+
+    if (previousRow_ != nullptr &&
+        compareRowsWithKeys(previousRow_, newRow, partitionKeyInfo_)) {
+      addPartitionInputs(true);
+    }
+
+    if (previousRow_ != nullptr && inputRows_.size() >= numRowsPerOutput_) {
+      addPartitionInputs(false);
+    }
+
+    inputRows_.push_back(newRow);
+    previousRow_ = newRow;
+  }
+}
+
+void RowsStreamingWindowBuild::noMoreInput() {
+  addPartitionInputs(true);
+}
+
+std::shared_ptr<WindowPartition> RowsStreamingWindowBuild::nextPartition() {
+  VELOX_CHECK(hasNextPartition());
+  return windowPartitions_[++outputPartition_];
+}
+
+bool RowsStreamingWindowBuild::hasNextPartition() {
+  return !windowPartitions_.empty() &&
+      outputPartition_ + 2 <= windowPartitions_.size();
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/RowsStreamingWindowBuild.h b/velox/exec/RowsStreamingWindowBuild.h
new file mode 100644
index 0000000000000..c003f1e6a3f9b
--- /dev/null
+++ b/velox/exec/RowsStreamingWindowBuild.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "velox/exec/WindowBuild.h"
+
+namespace facebook::velox::exec {
+
+/// Unlike PartitionStreamingWindowBuild, RowsStreamingWindowBuild is capable of
+/// processing window functions as rows arrive within a single partition,
+/// without the need to wait for the entirewindow partition to be ready. This
+/// approach can significantly reduce memory usage, especially when a single
+/// partition contains a large amount of data. It is particularly suited for
+/// optimizing rank, dense_rank and row_number functions, as well as aggregate
+/// window functions with a default frame.
+class RowsStreamingWindowBuild : public WindowBuild {
+ public:
+  RowsStreamingWindowBuild(
+      const std::shared_ptr<const core::WindowNode>& windowNode,
+      velox::memory::MemoryPool* pool,
+      const common::SpillConfig* spillConfig,
+      tsan_atomic<bool>* nonReclaimableSection);
+
+  void addInput(RowVectorPtr input) override;
+
+  void spill() override {
+    VELOX_UNREACHABLE();
+  }
+
+  std::optional<common::SpillStats> spilledStats() const override {
+    return std::nullopt;
+  }
+
+  void noMoreInput() override;
+
+  bool hasNextPartition() override;
+
+  std::shared_ptr<WindowPartition> nextPartition() override;
+
+  bool needsInput() override {
+    // No partitions are available or the currentPartition is the last available
+    // one, so can consume input rows.
+    return windowPartitions_.empty() ||
+        outputPartition_ == windowPartitions_.size() - 1;
+  }
+
+ private:
+  // Adds input rows to the current partition, or creates a new partition if it
+  // does not exist.
+  void addPartitionInputs(bool finished);
+
+  // Points to the input rows in the current partition.
+  std::vector<char*> inputRows_;
+
+  // Used to compare rows based on partitionKeys.
+  char* previousRow_ = nullptr;
+
+  // Point to the current output partition if not -1.
+  vector_size_t outputPartition_ = -1;
+
+  // Current input partition that receives inputs.
+  vector_size_t inputPartition_ = 0;
+
+  // Holds all the built window partitions.
+  std::vector<std::shared_ptr<WindowPartition>> windowPartitions_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SortWindowBuild.cpp b/velox/exec/SortWindowBuild.cpp
index c65009012fdd4..400b1edbe636f 100644
--- a/velox/exec/SortWindowBuild.cpp
+++ b/velox/exec/SortWindowBuild.cpp
@@ -294,11 +294,11 @@ void SortWindowBuild::loadNextPartitionFromSpill() {
   }
 }
 
-std::unique_ptr<WindowPartition> SortWindowBuild::nextPartition() {
+std::shared_ptr<WindowPartition> SortWindowBuild::nextPartition() {
   if (merge_ != nullptr) {
     VELOX_CHECK(!sortedRows_.empty(), "No window partitions available")
     auto partition = folly::Range(sortedRows_.data(), sortedRows_.size());
-    return std::make_unique<WindowPartition>(
+    return std::make_shared<WindowPartition>(
         data_.get(), partition, inversedInputChannels_, sortKeyInfo_);
   }
 
@@ -316,7 +316,7 @@ std::unique_ptr<WindowPartition> SortWindowBuild::nextPartition() {
   auto partition = folly::Range(
       sortedRows_.data() + partitionStartRows_[currentPartition_],
       partitionSize);
-  return std::make_unique<WindowPartition>(
+  return std::make_shared<WindowPartition>(
       data_.get(), partition, inversedInputChannels_, sortKeyInfo_);
 }
 
diff --git a/velox/exec/SortWindowBuild.h b/velox/exec/SortWindowBuild.h
index 645949ddb7e02..0caecfe6a5c37 100644
--- a/velox/exec/SortWindowBuild.h
+++ b/velox/exec/SortWindowBuild.h
@@ -53,7 +53,7 @@ class SortWindowBuild : public WindowBuild {
 
   bool hasNextPartition() override;
 
-  std::unique_ptr<WindowPartition> nextPartition() override;
+  std::shared_ptr<WindowPartition> nextPartition() override;
 
  private:
   void ensureInputFits(const RowVectorPtr& input);
diff --git a/velox/exec/Window.cpp b/velox/exec/Window.cpp
index 4577388006fa2..e4d36d994591f 100644
--- a/velox/exec/Window.cpp
+++ b/velox/exec/Window.cpp
@@ -15,8 +15,9 @@
  */
 #include "velox/exec/Window.h"
 #include "velox/exec/OperatorUtils.h"
+#include "velox/exec/PartitionStreamingWindowBuild.h"
+#include "velox/exec/RowsStreamingWindowBuild.h"
 #include "velox/exec/SortWindowBuild.h"
-#include "velox/exec/StreamingWindowBuild.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
@@ -41,8 +42,13 @@ Window::Window(
   auto* spillConfig =
       spillConfig_.has_value() ? &spillConfig_.value() : nullptr;
   if (windowNode->inputsSorted()) {
-    windowBuild_ = std::make_unique<StreamingWindowBuild>(
-        windowNode, pool(), spillConfig, &nonReclaimableSection_);
+    if (supportRowsStreaming()) {
+      windowBuild_ = std::make_unique<RowsStreamingWindowBuild>(
+          windowNode_, pool(), spillConfig, &nonReclaimableSection_);
+    } else {
+      windowBuild_ = std::make_unique<PartitionStreamingWindowBuild>(
+          windowNode, pool(), spillConfig, &nonReclaimableSection_);
+    }
   } else {
     windowBuild_ = std::make_unique<SortWindowBuild>(
         windowNode, pool(), spillConfig, &nonReclaimableSection_, &spillStats_);
@@ -54,6 +60,7 @@ void Window::initialize() {
   VELOX_CHECK_NOT_NULL(windowNode_);
   createWindowFunctions();
   createPeerAndFrameBuffers();
+  windowBuild_->setNumRowsPerOutput(numRowsPerOutput_);
   windowNode_.reset();
 }
 
@@ -188,6 +195,31 @@ void Window::createWindowFunctions() {
   }
 }
 
+bool Window::supportRowsStreaming() {
+  for (const auto& windowFunction : windowNode_->windowFunctions()) {
+    const auto& functionName = windowFunction.functionCall->name();
+    const auto windowFunctionMetadata =
+        exec::getWindowFunctionMetadata(functionName);
+
+    if (windowFunctionMetadata.processMode !=
+        exec::WindowFunction::ProcessMode::kRows) {
+      return false;
+    }
+
+    const auto& frame = windowFunction.frame;
+    // The default frame spans from the start of the partition to current row.
+    const bool isDefaultFrame =
+        (frame.startType == core::WindowNode::BoundType::kUnboundedPreceding &&
+         frame.endType == core::WindowNode::BoundType::kCurrentRow);
+
+    if (windowFunctionMetadata.isAggregate && !isDefaultFrame) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 void Window::addInput(RowVectorPtr input) {
   windowBuild_->addInput(input);
   numRows_ += input->size();
@@ -542,9 +574,13 @@ void Window::callApplyForPartitionRows(
     vector_size_t endRow,
     vector_size_t resultOffset,
     const RowVectorPtr& result) {
-  getInputColumns(startRow, endRow, resultOffset, result);
-
+  // NOTE: for a partial window partition, the last row of the previously
+  // processed rows (used for peer group comparison) will be deleted by
+  // computePeerAndFrameBuffers after peer group comparison. Hence we need to
+  // call getInputColumns after computePeerAndFrameBuffers.
   computePeerAndFrameBuffers(startRow, endRow);
+
+  getInputColumns(startRow, endRow, resultOffset, result);
   vector_size_t numFuncs = windowFunctions_.size();
   for (auto i = 0; i < numFuncs; ++i) {
     windowFunctions_[i]->apply(
@@ -560,6 +596,10 @@ void Window::callApplyForPartitionRows(
   const vector_size_t numRows = endRow - startRow;
   numProcessedRows_ += numRows;
   partitionOffset_ += numRows;
+
+  if (currentPartition_->partial()) {
+    currentPartition_->removeProcessedRows(numRows);
+  }
 }
 
 vector_size_t Window::callApplyLoop(
@@ -573,18 +613,25 @@ vector_size_t Window::callApplyLoop(
   // This function requires that the currentPartition_ is available for output.
   VELOX_DCHECK_NOT_NULL(currentPartition_);
   while (numOutputRowsLeft > 0) {
-    const auto rowsForCurrentPartition =
-        currentPartition_->numRows() - partitionOffset_;
-    if (rowsForCurrentPartition <= numOutputRowsLeft) {
+    const auto numPartitionRows =
+        currentPartition_->numRowsForProcessing(partitionOffset_);
+    if (numPartitionRows <= numOutputRowsLeft) {
       // Current partition can fit completely in the output buffer.
       // So output all its rows.
       callApplyForPartitionRows(
           partitionOffset_,
-          partitionOffset_ + rowsForCurrentPartition,
+          partitionOffset_ + numPartitionRows,
           resultIndex,
           result);
-      resultIndex += rowsForCurrentPartition;
-      numOutputRowsLeft -= rowsForCurrentPartition;
+      resultIndex += numPartitionRows;
+      numOutputRowsLeft -= numPartitionRows;
+
+      if (!currentPartition_->complete()) {
+        // There are more data need to process for a partial partition.
+        VELOX_CHECK(currentPartition_->partial());
+        break;
+      }
+
       callResetPartition();
       if (currentPartition_ == nullptr) {
         // The WindowBuild doesn't have any more partitions to process right
@@ -627,6 +674,11 @@ RowVectorPtr Window::getOutput() {
     }
   }
 
+  if (!currentPartition_->complete() &&
+      (currentPartition_->numRowsForProcessing(partitionOffset_) == 0)) {
+    return nullptr;
+  }
+
   const auto numOutputRows = std::min(numRowsPerOutput_, numRowsLeft);
   auto result = BaseVector::create<RowVector>(
       outputType_, numOutputRows, operatorCtx_->pool());
diff --git a/velox/exec/Window.h b/velox/exec/Window.h
index 393bcc364accb..eb3389369a230 100644
--- a/velox/exec/Window.h
+++ b/velox/exec/Window.h
@@ -88,6 +88,11 @@ class Window : public Operator {
     const std::optional<FrameChannelArg> end;
   };
 
+  // Returns if a window operator support rows-wise streaming processing or not.
+  // Currently we supports 'rank', 'dense_rank' and 'row_number' functions with
+  // any frame type. Also supports the agg window function with default frame.
+  bool supportRowsStreaming();
+
   // Creates WindowFunction and frame objects for this operator.
   void createWindowFunctions();
 
@@ -165,7 +170,7 @@ class Window : public Operator {
 
   // Used to access window partition rows and columns by the window
   // operator and functions. This structure is owned by the WindowBuild.
-  std::unique_ptr<WindowPartition> currentPartition_;
+  std::shared_ptr<WindowPartition> currentPartition_;
 
   // HashStringAllocator required by functions that allocate out of line
   // buffers.
diff --git a/velox/exec/WindowBuild.h b/velox/exec/WindowBuild.h
index 1f9207c4fbd55..01c470803ed70 100644
--- a/velox/exec/WindowBuild.h
+++ b/velox/exec/WindowBuild.h
@@ -66,7 +66,7 @@ class WindowBuild {
   /// access the underlying columns of Window partition data. Check
   /// hasNextPartition() before invoking this function. This function fails if
   /// called when no partition is available.
-  virtual std::unique_ptr<WindowPartition> nextPartition() = 0;
+  virtual std::shared_ptr<WindowPartition> nextPartition() = 0;
 
   /// Returns the average size of input rows in bytes stored in the data
   /// container of the WindowBuild.
@@ -74,6 +74,10 @@ class WindowBuild {
     return data_->estimateRowSize();
   }
 
+  void setNumRowsPerOutput(vector_size_t numRowsPerOutput) {
+    numRowsPerOutput_ = numRowsPerOutput;
+  }
+
  protected:
   bool compareRowsWithKeys(
       const char* lhs,
@@ -111,6 +115,9 @@ class WindowBuild {
 
   /// Number of input rows.
   vector_size_t numRows_ = 0;
+
+  // The maximum number of rows that can fit into an output block.
+  vector_size_t numRowsPerOutput_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/WindowFunction.cpp b/velox/exec/WindowFunction.cpp
index b093024a1dbec..6eea3160b21ea 100644
--- a/velox/exec/WindowFunction.cpp
+++ b/velox/exec/WindowFunction.cpp
@@ -41,13 +41,24 @@ std::optional<const WindowFunctionEntry*> getWindowFunctionEntry(
 bool registerWindowFunction(
     const std::string& name,
     std::vector<FunctionSignaturePtr> signatures,
+    WindowFunction::Metadata metadata,
     WindowFunctionFactory factory) {
   auto sanitizedName = sanitizeName(name);
   windowFunctions()[sanitizedName] = {
-      std::move(signatures), std::move(factory)};
+      std::move(signatures), std::move(factory), std::move(metadata)};
   return true;
 }
 
+WindowFunction::Metadata getWindowFunctionMetadata(const std::string& name) {
+  const auto sanitizedName = sanitizeName(name);
+  if (auto func = getWindowFunctionEntry(sanitizedName)) {
+    return func.value()->metadata;
+  } else {
+    VELOX_USER_FAIL(
+        "Window function metadata not found for function: {}", name);
+  }
+}
+
 std::optional<std::vector<FunctionSignaturePtr>> getWindowFunctionSignatures(
     const std::string& name) {
   auto sanitizedName = sanitizeName(name);
diff --git a/velox/exec/WindowFunction.h b/velox/exec/WindowFunction.h
index ee0ef26869c1b..e9bea92ee2c23 100644
--- a/velox/exec/WindowFunction.h
+++ b/velox/exec/WindowFunction.h
@@ -33,6 +33,28 @@ struct WindowFunctionArg {
 
 class WindowFunction {
  public:
+  /// The data process mode for calculating the window function.
+  enum class ProcessMode {
+    /// Process can only start after all the rows from a partition become
+    /// available.
+    kPartition,
+    /// Process can start as soon as rows are available within a partition,
+    /// without waiting for all the rows in the partition to be ready.
+    kRows,
+  };
+
+  /// Indicates whether this is an aggregate window function and its process
+  /// unit.
+  struct Metadata {
+    ProcessMode processMode;
+    bool isAggregate;
+
+    static Metadata defaultMetadata() {
+      static Metadata defaultValue{ProcessMode::kPartition, false};
+      return defaultValue;
+    }
+  };
+
   explicit WindowFunction(
       TypePtr resultType,
       memory::MemoryPool* pool,
@@ -149,6 +171,7 @@ using WindowFunctionFactory = std::function<std::unique_ptr<WindowFunction>(
 bool registerWindowFunction(
     const std::string& name,
     std::vector<FunctionSignaturePtr> signatures,
+    WindowFunction::Metadata metadata,
     WindowFunctionFactory factory);
 
 /// Returns signatures of the window function with the specified name.
@@ -159,8 +182,12 @@ std::optional<std::vector<FunctionSignaturePtr>> getWindowFunctionSignatures(
 struct WindowFunctionEntry {
   std::vector<FunctionSignaturePtr> signatures;
   WindowFunctionFactory factory;
+  WindowFunction::Metadata metadata;
 };
 
+/// Returns window function metadata.
+WindowFunction::Metadata getWindowFunctionMetadata(const std::string& name);
+
 using WindowFunctionMap = std::unordered_map<std::string, WindowFunctionEntry>;
 
 /// Returns a map of all window function names to their registrations.
diff --git a/velox/exec/WindowPartition.cpp b/velox/exec/WindowPartition.cpp
index 2783b6b7b2f3b..f57077364c348 100644
--- a/velox/exec/WindowPartition.cpp
+++ b/velox/exec/WindowPartition.cpp
@@ -21,13 +21,70 @@ WindowPartition::WindowPartition(
     RowContainer* data,
     const folly::Range<char**>& rows,
     const std::vector<column_index_t>& inputMapping,
-    const std::vector<std::pair<column_index_t, core::SortOrder>>& sortKeyInfo)
-    : data_(data),
+    const std::vector<std::pair<column_index_t, core::SortOrder>>& sortKeyInfo,
+    bool partial,
+    bool complete)
+    : partial_(partial),
+      data_(data),
       partition_(rows),
+      complete_(complete),
       inputMapping_(inputMapping),
       sortKeyInfo_(sortKeyInfo) {
-  for (int i = 0; i < inputMapping_.size(); i++) {
-    columns_.emplace_back(data_->columnAt(inputMapping_[i]));
+  VELOX_CHECK_NE(partial_, complete_);
+  VELOX_CHECK_NE(complete_, partition_.empty());
+
+  for (auto index : inputMapping_) {
+    columns_.emplace_back(data_->columnAt(index));
+  }
+}
+
+WindowPartition::WindowPartition(
+    RowContainer* data,
+    const folly::Range<char**>& rows,
+    const std::vector<column_index_t>& inputMapping,
+    const std::vector<std::pair<column_index_t, core::SortOrder>>& sortKeyInfo)
+    : WindowPartition(data, rows, inputMapping, sortKeyInfo, false, true) {}
+
+WindowPartition::WindowPartition(
+    RowContainer* data,
+    const std::vector<column_index_t>& inputMapping,
+    const std::vector<std::pair<column_index_t, core::SortOrder>>& sortKeyInfo)
+    : WindowPartition(data, {}, inputMapping, sortKeyInfo, true, false) {}
+
+void WindowPartition::addRows(const std::vector<char*>& rows) {
+  checkPartial();
+  rows_.insert(rows_.end(), rows.begin(), rows.end());
+  partition_ = folly::Range(rows_.data(), rows_.size());
+}
+
+void WindowPartition::eraseRows(vector_size_t numRows) {
+  checkPartial();
+  VELOX_CHECK_GE(data_->numRows(), numRows);
+  data_->eraseRows(folly::Range<char**>(rows_.data(), numRows));
+}
+
+void WindowPartition::removeProcessedRows(vector_size_t numRows) {
+  checkPartial();
+
+  VELOX_CHECK_NULL(previousRow_);
+  if (complete_ && rows_.size() == numRows) {
+    eraseRows(numRows);
+  } else {
+    eraseRows(numRows - 1);
+    previousRow_ = rows_[numRows - 1];
+  }
+
+  rows_.erase(rows_.begin(), rows_.begin() + numRows);
+  partition_ = folly::Range(rows_.data(), rows_.size());
+  startRow_ += numRows;
+}
+
+vector_size_t WindowPartition::numRowsForProcessing(
+    vector_size_t partitionOffset) const {
+  if (partial_) {
+    return partition_.size();
+  } else {
+    return partition_.size() - partitionOffset;
   }
 }
 
@@ -50,8 +107,9 @@ void WindowPartition::extractColumn(
     vector_size_t numRows,
     vector_size_t resultOffset,
     const VectorPtr& result) const {
+  VELOX_CHECK_GE(partitionOffset, startRow_);
   RowContainer::extractColumn(
-      partition_.data() + partitionOffset,
+      partition_.data() + partitionOffset - startRow_,
       numRows,
       columns_[columnIndex],
       resultOffset,
@@ -130,23 +188,65 @@ bool WindowPartition::compareRowsWithSortKeys(const char* lhs, const char* rhs)
   return false;
 }
 
+vector_size_t WindowPartition::findPeerRowEndIndex(
+    vector_size_t startRow,
+    vector_size_t lastRow,
+    const std::function<bool(const char*, const char*)>& peerCompare) {
+  auto peerEnd = startRow;
+  while (peerEnd <= lastRow) {
+    if (peerCompare(
+            partition_[startRow - startRow_],
+            partition_[peerEnd - startRow_])) {
+      break;
+    }
+    ++peerEnd;
+  }
+  return peerEnd;
+}
+
+void WindowPartition::removePreviousRow() {
+  VELOX_CHECK_NOT_NULL(previousRow_);
+  data_->eraseRows(folly::Range<char**>(&previousRow_, 1));
+  previousRow_ = nullptr;
+}
+
 std::pair<vector_size_t, vector_size_t> WindowPartition::computePeerBuffers(
     vector_size_t start,
     vector_size_t end,
     vector_size_t prevPeerStart,
     vector_size_t prevPeerEnd,
     vector_size_t* rawPeerStarts,
-    vector_size_t* rawPeerEnds) const {
+    vector_size_t* rawPeerEnds) {
   const auto peerCompare = [&](const char* lhs, const char* rhs) -> bool {
     return compareRowsWithSortKeys(lhs, rhs);
   };
 
-  VELOX_CHECK_LE(end, numRows());
+  VELOX_CHECK_LE(end, numRows() + startRow_);
 
-  const auto lastPartitionRow = numRows() - 1;
+  auto lastPartitionRow = numRows() + startRow_ - 1;
   auto peerStart = prevPeerStart;
   auto peerEnd = prevPeerEnd;
-  for (auto i = start, j = 0; i < end; ++i, ++j) {
+
+  size_t next = start;
+  size_t index{0};
+  if (partial_ && start > 0) {
+    const auto peerGroup = peerCompare(previousRow_, partition_[0]);
+
+    // The first row is the last row in previous batch so delete it after used
+    // for the first peer group detection.
+    removePreviousRow();
+
+    if (!peerGroup) {
+      peerEnd = findPeerRowEndIndex(start, lastPartitionRow, peerCompare);
+
+      for (; next < std::min(end, peerEnd); ++next, ++index) {
+        rawPeerStarts[index] = peerStart;
+        rawPeerEnds[index] = peerEnd - 1;
+      }
+    }
+  }
+
+  for (; next < end; ++next, ++index) {
     // When traversing input partition rows, the peers are the rows with the
     // same values for the ORDER BY clause. These rows are equal in some ways
     // and affect the results of ranking functions. This logic exploits the fact
@@ -155,22 +255,17 @@ std::pair<vector_size_t, vector_size_t> WindowPartition::computePeerBuffers(
     // across the rows in that peer interval. Note: peerStart and peerEnd can be
     // maintained across getOutput calls. Hence, they are returned to the
     // caller.
-    if (i == 0 || i >= peerEnd) {
+    if (next == 0 || next >= peerEnd) {
       // Compute peerStart and peerEnd rows for the first row of the partition
       // or when past the previous peerGroup.
-      peerStart = i;
-      peerEnd = i;
-      while (peerEnd <= lastPartitionRow) {
-        if (peerCompare(partition_[peerStart], partition_[peerEnd])) {
-          break;
-        }
-        ++peerEnd;
-      }
+      peerStart = next;
+      peerEnd = findPeerRowEndIndex(peerStart, lastPartitionRow, peerCompare);
     }
 
-    rawPeerStarts[j] = peerStart;
-    rawPeerEnds[j] = peerEnd - 1;
+    rawPeerStarts[index] = peerStart;
+    rawPeerEnds[index] = peerEnd - 1;
   }
+  VELOX_CHECK_EQ(index, end - start);
   return {peerStart, peerEnd};
 }
 
diff --git a/velox/exec/WindowPartition.h b/velox/exec/WindowPartition.h
index 7073af3a42383..7948611a98295 100644
--- a/velox/exec/WindowPartition.h
+++ b/velox/exec/WindowPartition.h
@@ -20,9 +20,14 @@
 
 /// Simple WindowPartition that builds over the RowContainer used for storing
 /// the input rows in the Window Operator. This works completely in-memory.
+/// WindowPartition supports partial window partitioning to facilitate
+/// RowsStreamingWindowBuild which can start data processing with a portion set
+/// of rows without having to wait until an entire partition of rows are ready.
+
 /// TODO: This implementation will be revised for Spill to disk semantics.
 
 namespace facebook::velox::exec {
+
 class WindowPartition {
  public:
   /// The WindowPartition is used by the Window operator and WindowFunction
@@ -42,11 +47,46 @@ class WindowPartition {
       const std::vector<std::pair<column_index_t, core::SortOrder>>&
           sortKeyInfo);
 
+  /// The WindowPartition is used for RowStreamingWindowBuild which allows to
+  /// start data processing with a subset of partition rows. 'partial_' flag is
+  /// set for the constructed window partition.
+  WindowPartition(
+      RowContainer* data,
+      const std::vector<column_index_t>& inputMapping,
+      const std::vector<std::pair<column_index_t, core::SortOrder>>&
+          sortKeyInfo);
+
+  /// Adds remaining input 'rows' for a partial window partition.
+  void addRows(const std::vector<char*>& rows);
+
+  /// Removes the first 'numRows' in 'rows_' from a partial window partition
+  /// after been processed.
+  void removeProcessedRows(vector_size_t numRows);
+
   /// Returns the number of rows in the current WindowPartition.
   vector_size_t numRows() const {
     return partition_.size();
   }
 
+  /// Returns the number of rows in a window partition remaining for data
+  /// processing.
+  vector_size_t numRowsForProcessing(vector_size_t partitionOffset) const;
+
+  bool complete() const {
+    return complete_;
+  }
+
+  bool partial() const {
+    return partial_;
+  }
+
+  void setComplete() {
+    VELOX_CHECK(!complete_);
+    checkPartial();
+
+    complete_ = true;
+  }
+
   /// Copies the values at 'columnIndex' into 'result' (starting at
   /// 'resultOffset') for the rows at positions in the 'rowNumbers'
   /// array from the partition input data.
@@ -107,7 +147,7 @@ class WindowPartition {
       vector_size_t prevPeerStart,
       vector_size_t prevPeerEnd,
       vector_size_t* rawPeerStarts,
-      vector_size_t* rawPeerEnds) const;
+      vector_size_t* rawPeerEnds);
 
   /// Sets in 'rawFrameBounds' the frame boundary for the k range
   /// preceding/following frame.
@@ -128,8 +168,33 @@ class WindowPartition {
       vector_size_t* rawFrameBounds) const;
 
  private:
+  WindowPartition(
+      RowContainer* data,
+      const folly::Range<char**>& rows,
+      const std::vector<column_index_t>& inputMapping,
+      const std::vector<std::pair<column_index_t, core::SortOrder>>&
+          sortKeyInfo,
+      bool partial,
+      bool complete);
+
   bool compareRowsWithSortKeys(const char* lhs, const char* rhs) const;
 
+  // Finds the index of the last peer row in range of ['startRow', 'lastRow'].
+  vector_size_t findPeerRowEndIndex(
+      vector_size_t startRow,
+      vector_size_t lastRow,
+      const std::function<bool(const char*, const char*)>& peerCompare);
+
+  // Removes 'numRows' from 'data_' and 'rows_'.
+  void eraseRows(vector_size_t numRows);
+
+  void checkPartial() const {
+    VELOX_CHECK(partial_, "WindowPartition should be partial");
+  }
+
+  // Removes the previous row from 'data_'.
+  void removePreviousRow();
+
   // Searches for 'currentRow[frameColumn]' in 'orderByColumn' of rows between
   // 'start' and 'end' in the partition. 'firstMatch' specifies if first or last
   // row is matched.
@@ -162,9 +227,16 @@ class WindowPartition {
       const vector_size_t* rawPeerBounds,
       vector_size_t* rawFrameBounds) const;
 
+  // Indicates if this is a partial partition for RowStreamWindowBuild
+  // processing.
+  const bool partial_;
+
   // The RowContainer associated with the partition.
   // It is owned by the WindowBuild that creates the partition.
-  RowContainer* data_;
+  RowContainer* const data_;
+
+  // Points to the input rows for partial partition.
+  std::vector<char*> rows_;
 
   // folly::Range is for the partition rows iterator provided by the
   // Window operator. The pointers are to rows from a RowContainer owned
@@ -172,6 +244,10 @@ class WindowPartition {
   // of WindowPartition.
   folly::Range<char**> partition_;
 
+  // Indicates if a partial partition has received all the input rows. For a
+  // non-partial partition, this is always true.
+  bool complete_ = true;
+
   // Mapping from window input column -> index in data_. This is required
   // because the WindowBuild reorders data_ to place partition and sort keys
   // before other columns in data_. But the Window Operator and Function code
@@ -189,5 +265,15 @@ class WindowPartition {
   // corresponding indexes of their input arguments into this vector.
   // They will request for column vector values at the respective index.
   std::vector<exec::RowColumn> columns_;
+
+  // The partition offset of the first row in 'rows_'. It is updated for
+  // partial partition during the data processing but always zero for
+  // non-partial partition.
+  vector_size_t startRow_{0};
+
+  // Points to the last row from the previous processed peer group if not null.
+  // This is only set for a partial window partition and always null for a
+  // non-partial one.
+  char* previousRow_{nullptr};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/PlanBuilderTest.cpp b/velox/exec/tests/PlanBuilderTest.cpp
index 5204e92744035..c4b22f3678b81 100644
--- a/velox/exec/tests/PlanBuilderTest.cpp
+++ b/velox/exec/tests/PlanBuilderTest.cpp
@@ -98,7 +98,11 @@ void registerWindowFunction() {
           .returnType("BIGINT")
           .build(),
   };
-  exec::registerWindowFunction("window1", std::move(signatures), nullptr);
+  exec::registerWindowFunction(
+      "window1",
+      std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
+      nullptr);
 }
 } // namespace
 
diff --git a/velox/exec/tests/PlanNodeToStringTest.cpp b/velox/exec/tests/PlanNodeToStringTest.cpp
index b40463e4d55ca..59485b89478f2 100644
--- a/velox/exec/tests/PlanNodeToStringTest.cpp
+++ b/velox/exec/tests/PlanNodeToStringTest.cpp
@@ -729,7 +729,11 @@ TEST_F(PlanNodeToStringTest, window) {
           .returnType("BIGINT")
           .build(),
   };
-  exec::registerWindowFunction("window1", std::move(signatures), nullptr);
+  exec::registerWindowFunction(
+      "window1",
+      std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
+      nullptr);
 
   auto plan =
       PlanBuilder()
diff --git a/velox/exec/tests/WindowFunctionRegistryTest.cpp b/velox/exec/tests/WindowFunctionRegistryTest.cpp
index b0aee416caf73..f78b18a050248 100644
--- a/velox/exec/tests/WindowFunctionRegistryTest.cpp
+++ b/velox/exec/tests/WindowFunctionRegistryTest.cpp
@@ -37,7 +37,11 @@ void registerWindowFunction(const std::string& name) {
           .build(),
       exec::FunctionSignatureBuilder().returnType("date").build(),
   };
-  exec::registerWindowFunction(name, std::move(signatures), nullptr);
+  exec::registerWindowFunction(
+      name,
+      std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
+      nullptr);
 }
 } // namespace
 
diff --git a/velox/exec/tests/WindowTest.cpp b/velox/exec/tests/WindowTest.cpp
index febdcd743d30a..a55b6f4598ab2 100644
--- a/velox/exec/tests/WindowTest.cpp
+++ b/velox/exec/tests/WindowTest.cpp
@@ -13,9 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/RowsStreamingWindowBuild.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -79,6 +81,262 @@ TEST_F(WindowTest, spill) {
   ASSERT_GT(stats.spilledPartitions, 0);
 }
 
+TEST_F(WindowTest, rowBasedStreamingWindowOOM) {
+  const vector_size_t size = 1'000'000;
+  auto data = makeRowVector(
+      {"d", "p", "s"},
+      {
+          // Payload.
+          makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+          // Partition key.
+          makeFlatVector<int16_t>(size, [](auto row) { return row; }),
+          // Sorting key.
+          makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable({data});
+
+  // Abstract the common values vector split.
+  auto valuesSplit = split(data, 10);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  auto queryCtx = core::QueryCtx::create(executor_.get());
+  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
+      queryCtx->queryId(),
+      8'388'608 /* 8MB */,
+      exec::MemoryReclaimer::create()));
+
+  params.queryCtx = queryCtx;
+
+  auto testWindowBuild = [&](bool useStreamingWindow) {
+    if (useStreamingWindow) {
+      params.planNode =
+          PlanBuilder(planNodeIdGenerator)
+              .values(valuesSplit)
+              .streamingWindow(
+                  {"row_number() over (partition by p order by s)"})
+              .project({"d"})
+              .singleAggregation({}, {"sum(d)"})
+              .planNode();
+
+      readCursor(params, [](Task*) {});
+    } else {
+      params.planNode =
+          PlanBuilder(planNodeIdGenerator)
+              .values(valuesSplit)
+              .window({"row_number() over (partition by p order by s)"})
+              .project({"d"})
+              .singleAggregation({}, {"sum(d)"})
+              .planNode();
+
+      VELOX_ASSERT_THROW(
+          readCursor(params, [](Task*) {}),
+          "Exceeded memory pool capacity after attempt to grow capacity through arbitration.");
+    }
+  };
+  // RowStreamingWindow will not OOM.
+  testWindowBuild(true);
+  // SortBasedWindow will OOM.
+  testWindowBuild(false);
+}
+
+TEST_F(WindowTest, rowBasedStreamingWindowMemoryUsage) {
+  auto memoryUsage = [&](bool useStreamingWindow, vector_size_t size) {
+    auto data = makeRowVector(
+        {"d", "p", "s"},
+        {
+            // Payload.
+            makeFlatVector<int64_t>(size, [](auto row) { return row; }),
+            // Partition key.
+            makeFlatVector<int16_t>(size, [](auto row) { return row % 11; }),
+            // Sorting key.
+            makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+        });
+
+    createDuckDbTable({data});
+
+    // Abstract the common values vector split.
+    auto valuesSplit = split(data, 10);
+    core::PlanNodeId windowId;
+    auto builder = PlanBuilder().values(valuesSplit);
+    if (useStreamingWindow) {
+      builder.orderBy({"p", "s"}, false)
+          .streamingWindow({"row_number() over (partition by p order by s)"});
+    } else {
+      builder.window({"row_number() over (partition by p order by s)"});
+    }
+    auto plan = builder.capturePlanNodeId(windowId).planNode();
+    auto task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+            .assertResults(
+                "SELECT *, row_number() over (partition by p order by s) FROM tmp");
+
+    return exec::toPlanStats(task->taskStats()).at(windowId).peakMemoryBytes;
+  };
+
+  const vector_size_t smallSize = 100'000;
+  const vector_size_t largeSize = 1'000'000;
+  // As the volume of data increases, the peak memory usage of the sort-based
+  // window will increase (2418624 vs 17098688). Since the peak memory usage of
+  // the RowBased Window represents the one batch data in a single partition,
+  // the peak memory usage will not increase as the volume of data grows.
+  auto sortWindowSmallUsage = memoryUsage(false, smallSize);
+  auto sortWindowLargeUsage = memoryUsage(false, largeSize);
+  ASSERT_GT(sortWindowLargeUsage, sortWindowSmallUsage);
+
+  auto rowWindowSmallUsage = memoryUsage(true, smallSize);
+  auto rowWindowLargeUsage = memoryUsage(true, largeSize);
+  ASSERT_EQ(rowWindowSmallUsage, rowWindowLargeUsage);
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, rankRowStreamingWindowBuild) {
+  auto data = makeRowVector(
+      {"c1"},
+      {makeFlatVector<int64_t>(std::vector<int64_t>{1, 1, 1, 1, 1, 2, 2})});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "rank() over (order by c1 rows unbounded preceding)"};
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .orderBy({"c1"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+      .config(core::QueryConfig::kMaxOutputBatchRows, "2")
+      .assertResults(
+          "SELECT *, rank() over (order by c1 rows unbounded preceding) FROM tmp");
+
+  ASSERT_TRUE(isStreamCreated.load());
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, valuesRowsStreamingWindowBuild) {
+  const vector_size_t size = 1'00;
+
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 50; }),
+       makeFlatVector<int64_t>(
+           size, [](auto row) { return row % 3 + 1; }, nullEvery(5)),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 40; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row; })});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "rank() over (partition by c0, c2 order by c1, c3)",
+      "dense_rank() over (partition by c0, c2 order by c1, c3)",
+      "row_number() over (partition by c0, c2 order by c1, c3)",
+      "sum(c4) over (partition by c0, c2 order by c1, c3)"};
+
+  auto plan = PlanBuilder()
+                  .values({split(data, 10)})
+                  .orderBy({"c0", "c2", "c1", "c3"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .assertResults(
+          "SELECT *, rank() over (partition by c0, c2 order by c1, c3), dense_rank() over (partition by c0, c2 order by c1, c3), row_number() over (partition by c0, c2 order by c1, c3), sum(c4) over (partition by c0, c2 order by c1, c3) FROM tmp");
+  ASSERT_TRUE(isStreamCreated.load());
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, aggregationWithNonDefaultFrame) {
+  const vector_size_t size = 1'00;
+
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>(size, [](auto row) { return row % 5; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 50; }),
+       makeFlatVector<int64_t>(
+           size, [](auto row) { return row % 3 + 1; }, nullEvery(5)),
+       makeFlatVector<int32_t>(size, [](auto row) { return row % 40; }),
+       makeFlatVector<int32_t>(size, [](auto row) { return row; })});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "sum(c4) over (partition by c0, c2 order by c1, c3 range between unbounded preceding and unbounded following)"};
+
+  auto plan = PlanBuilder()
+                  .values({split(data, 10)})
+                  .orderBy({"c0", "c2", "c1", "c3"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .assertResults(
+          "SELECT *, sum(c4) over (partition by c0, c2 order by c1, c3 range between unbounded preceding and unbounded following) FROM tmp");
+
+  ASSERT_FALSE(isStreamCreated.load());
+}
+
+DEBUG_ONLY_TEST_F(WindowTest, nonRowsStreamingWindow) {
+  auto data = makeRowVector(
+      {"c1"},
+      {makeFlatVector<int64_t>(std::vector<int64_t>{1, 1, 1, 1, 1, 2, 2})});
+
+  createDuckDbTable({data});
+
+  const std::vector<std::string> kClauses = {
+      "first_value(c1) over (order by c1 rows unbounded preceding)",
+      "nth_value(c1, 1) over (order by c1 rows unbounded preceding)"};
+
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .orderBy({"c1"}, false)
+                  .streamingWindow(kClauses)
+                  .planNode();
+
+  std::atomic_bool isStreamCreated{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::RowsStreamingWindowBuild::RowsStreamingWindowBuild",
+      std::function<void(RowsStreamingWindowBuild*)>(
+          [&](RowsStreamingWindowBuild* windowBuild) {
+            isStreamCreated.store(true);
+          }));
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+      .config(core::QueryConfig::kMaxOutputBatchRows, "2")
+      .assertResults(
+          "SELECT *, first_value(c1) over (order by c1 rows unbounded preceding), nth_value(c1, 1) over (order by c1 rows unbounded preceding) FROM tmp");
+  ASSERT_FALSE(isStreamCreated.load());
+}
+
 TEST_F(WindowTest, missingFunctionSignature) {
   auto input = {makeRowVector({
       makeFlatVector<int64_t>({1, 2, 3}),
diff --git a/velox/functions/lib/window/NthValue.cpp b/velox/functions/lib/window/NthValue.cpp
index 8fd456c620cc4..5ef33fc303cd0 100644
--- a/velox/functions/lib/window/NthValue.cpp
+++ b/velox/functions/lib/window/NthValue.cpp
@@ -319,6 +319,7 @@ void registerNthValue(const std::string& name, TypeKind offsetTypeKind) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
           const TypePtr& resultType,
diff --git a/velox/functions/lib/window/Ntile.cpp b/velox/functions/lib/window/Ntile.cpp
index eacd562d2744f..8b4460b90b42c 100644
--- a/velox/functions/lib/window/Ntile.cpp
+++ b/velox/functions/lib/window/Ntile.cpp
@@ -241,6 +241,7 @@ void registerNtile(const std::string& name, const std::string& type) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
           const TypePtr& resultType,
diff --git a/velox/functions/lib/window/Rank.cpp b/velox/functions/lib/window/Rank.cpp
index 646557a2e30ce..625d2bd3b977f 100644
--- a/velox/functions/lib/window/Rank.cpp
+++ b/velox/functions/lib/window/Rank.cpp
@@ -97,9 +97,7 @@ void registerRankInternal(
       exec::FunctionSignatureBuilder().returnType(returnType).build(),
   };
 
-  exec::registerWindowFunction(
-      name,
-      std::move(signatures),
+  auto windowFunctionFactory =
       [name](
           const std::vector<exec::WindowFunctionArg>& /*args*/,
           const TypePtr& resultType,
@@ -107,9 +105,23 @@ void registerRankInternal(
           velox::memory::MemoryPool* /*pool*/,
           HashStringAllocator* /*stringAllocator*/,
           const core::QueryConfig& /*queryConfig*/)
-          -> std::unique_ptr<exec::WindowFunction> {
-        return std::make_unique<RankFunction<TRank, TResult>>(resultType);
-      });
+      -> std::unique_ptr<exec::WindowFunction> {
+    return std::make_unique<RankFunction<TRank, TResult>>(resultType);
+  };
+
+  if constexpr (TRank == RankType::kRank || TRank == RankType::kDenseRank) {
+    exec::registerWindowFunction(
+        name,
+        std::move(signatures),
+        {exec::WindowFunction::ProcessMode::kRows, false},
+        std::move(windowFunctionFactory));
+  } else {
+    exec::registerWindowFunction(
+        name,
+        std::move(signatures),
+        exec::WindowFunction::Metadata::defaultMetadata(),
+        std::move(windowFunctionFactory));
+  }
 }
 
 void registerRankBigint(const std::string& name) {
diff --git a/velox/functions/lib/window/RowNumber.cpp b/velox/functions/lib/window/RowNumber.cpp
index 16b7feb0a5431..81fc7e5e0c6d4 100644
--- a/velox/functions/lib/window/RowNumber.cpp
+++ b/velox/functions/lib/window/RowNumber.cpp
@@ -75,6 +75,7 @@ void registerRowNumber(const std::string& name, TypeKind resultTypeKind) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      {exec::WindowFunction::ProcessMode::kRows, false},
       [name](
           const std::vector<exec::WindowFunctionArg>& /*args*/,
           const TypePtr& resultType,
diff --git a/velox/functions/prestosql/window/CumeDist.cpp b/velox/functions/prestosql/window/CumeDist.cpp
index 98b264ec9ca92..439693e7ccc71 100644
--- a/velox/functions/prestosql/window/CumeDist.cpp
+++ b/velox/functions/prestosql/window/CumeDist.cpp
@@ -74,6 +74,7 @@ void registerCumeDist(const std::string& name) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& /*args*/,
           const TypePtr& /*resultType*/,
diff --git a/velox/functions/prestosql/window/FirstLastValue.cpp b/velox/functions/prestosql/window/FirstLastValue.cpp
index eaec4db987037..8aff5e26d2a2a 100644
--- a/velox/functions/prestosql/window/FirstLastValue.cpp
+++ b/velox/functions/prestosql/window/FirstLastValue.cpp
@@ -175,6 +175,7 @@ void registerFirstLastInternal(const std::string& name) {
   exec::registerWindowFunction(
       name,
       std::move(signatures),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [](const std::vector<exec::WindowFunctionArg>& args,
          const TypePtr& resultType,
          bool ignoreNulls,
diff --git a/velox/functions/prestosql/window/LeadLag.cpp b/velox/functions/prestosql/window/LeadLag.cpp
index 8e4c598c4d637..9d65351c76d56 100644
--- a/velox/functions/prestosql/window/LeadLag.cpp
+++ b/velox/functions/prestosql/window/LeadLag.cpp
@@ -424,6 +424,7 @@ void registerLag(const std::string& name) {
   exec::registerWindowFunction(
       name,
       signatures(),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
           const TypePtr& resultType,
@@ -441,6 +442,7 @@ void registerLead(const std::string& name) {
   exec::registerWindowFunction(
       name,
       signatures(),
+      exec::WindowFunction::Metadata::defaultMetadata(),
       [name](
           const std::vector<exec::WindowFunctionArg>& args,
           const TypePtr& resultType,

From 3bf1a74042e83981630d24c1eaee190d1f31aac2 Mon Sep 17 00:00:00 2001
From: Jimmy Lu <jimmylu@meta.com>
Date: Mon, 26 Aug 2024 13:29:21 -0700
Subject: [PATCH 21/24] Fix LEFT and ANTI joins to preserve probe order
 (#10832)

Summary:
Pull Request resolved: https://github.com/facebookincubator/velox/pull/10832

Currently for LEFT and ANTI joins, when there is a carryover missing
row from previous batch, we keep it and add it at end of current batch if there
is capacity, which breaks the order of probe side rows.

To fix this we simplify the logic of `NoMatchDetector` to emit rows in order.
As a result of that, the carryover row will be added as soon as we can decide it
needs to be added to output; this means we need to make one row extra space on
output buffers for the carryover case.  In the same case we also need to use
temporary buffers to avoid data being overwritten before we read them.

Reviewed By: mbasmanova

Differential Revision: D61795406

fbshipit-source-id: 7f972701718fb62d60c7122ee5432f47fec8e241
---
 velox/core/PlanNode.h             |   4 ++
 velox/exec/HashProbe.cpp          | 106 +++++++++++++++++++++++-------
 velox/exec/HashProbe.h            |  91 +++++++------------------
 velox/exec/tests/HashJoinTest.cpp |  42 ++++++++++++
 4 files changed, 153 insertions(+), 90 deletions(-)

diff --git a/velox/core/PlanNode.h b/velox/core/PlanNode.h
index ffe37eb8dbe9b..4013d7a2dee7a 100644
--- a/velox/core/PlanNode.h
+++ b/velox/core/PlanNode.h
@@ -1526,6 +1526,10 @@ class AbstractJoinNode : public PlanNode {
     return joinType_ == JoinType::kAnti;
   }
 
+  bool isPreservingProbeOrder() const {
+    return isInnerJoin() || isLeftJoin() || isAntiJoin();
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& leftKeys() const {
     return leftKeys_;
   }
diff --git a/velox/exec/HashProbe.cpp b/velox/exec/HashProbe.cpp
index 95f060b789148..defbbcdd8e119 100644
--- a/velox/exec/HashProbe.cpp
+++ b/velox/exec/HashProbe.cpp
@@ -986,9 +986,18 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
   auto outputBatchSize = (isLeftSemiOrAntiJoinNoFilter || emptyBuildSide)
       ? inputSize
       : outputBatchSize_;
-  auto mapping =
-      initializeRowNumberMapping(outputRowMapping_, outputBatchSize, pool());
-  outputTableRows_.resize(outputBatchSize);
+  auto outputBatchCapacity = outputBatchSize;
+  if (filter_ &&
+      (isLeftJoin(joinType_) || isFullJoin(joinType_) ||
+       isAntiJoin(joinType_))) {
+    // If we need non-matching probe side row, there is a possibility that such
+    // row exists at end of an input batch and being carried over in the next
+    // output batch, so we need to make extra room of one row in output.
+    ++outputBatchCapacity;
+  }
+  auto mapping = initializeRowNumberMapping(
+      outputRowMapping_, outputBatchCapacity, pool());
+  outputTableRows_.resize(outputBatchCapacity);
 
   for (;;) {
     int numOut = 0;
@@ -996,8 +1005,11 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
     if (emptyBuildSide) {
       // When build side is empty, anti and left joins return all probe side
       // rows, including ones with null join keys.
-      std::iota(mapping.begin(), mapping.end(), 0);
-      std::fill(outputTableRows_.begin(), outputTableRows_.end(), nullptr);
+      std::iota(mapping.begin(), mapping.begin() + inputSize, 0);
+      std::fill(
+          outputTableRows_.begin(),
+          outputTableRows_.begin() + inputSize,
+          nullptr);
       numOut = inputSize;
     } else if (isAntiJoin(joinType_) && !filter_) {
       if (nullAware_) {
@@ -1024,8 +1036,8 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
       numOut = table_->listJoinResults(
           *resultIter_,
           joinIncludesMissesFromLeft(joinType_),
-          mapping,
-          folly::Range(outputTableRows_.data(), outputTableRows_.size()),
+          folly::Range(mapping.data(), outputBatchSize),
+          folly::Range(outputTableRows_.data(), outputBatchSize),
           operatorCtx_->driverCtx()->queryConfig().preferredOutputBatchBytes());
     }
 
@@ -1036,7 +1048,7 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
       input_ = nullptr;
       return nullptr;
     }
-    VELOX_CHECK_LE(numOut, outputTableRows_.size());
+    VELOX_CHECK_LE(numOut, outputBatchSize);
 
     numOut = evalFilter(numOut);
 
@@ -1302,6 +1314,19 @@ SelectivityVector HashProbe::evalFilterForNullAwareJoin(
   return filterPassedRows;
 }
 
+namespace {
+
+template <typename T>
+T* initBuffer(BufferPtr& buffer, vector_size_t size, memory::MemoryPool* pool) {
+  VELOX_CHECK(!buffer || buffer->isMutable());
+  if (!buffer || buffer->size() < size * sizeof(T)) {
+    buffer = AlignedBuffer::allocate<T>(size, pool);
+  }
+  return buffer->asMutable<T>();
+}
+
+} // namespace
+
 int32_t HashProbe::evalFilter(int32_t numRows) {
   if (!filter_) {
     return numRows;
@@ -1343,21 +1368,51 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
   if (isLeftJoin(joinType_) || isFullJoin(joinType_)) {
     // Identify probe rows which got filtered out and add them back with nulls
     // for build side.
-    auto addMiss = [&](auto row) {
-      outputTableRows_[numPassed] = nullptr;
-      rawOutputProbeRowMapping[numPassed++] = row;
-    };
-    for (auto i = 0; i < numRows; ++i) {
-      const bool passed = filterPassed(i);
-      noMatchDetector_.advance(rawOutputProbeRowMapping[i], passed, addMiss);
-      if (passed) {
-        outputTableRows_[numPassed] = outputTableRows_[i];
-        rawOutputProbeRowMapping[numPassed++] = rawOutputProbeRowMapping[i];
+    if (noMatchDetector_.hasLastMissedRow()) {
+      auto* tempOutputTableRows = initBuffer<char*>(
+          tempOutputTableRows_, outputTableRows_.size(), pool());
+      auto* tempOutputRowMapping = initBuffer<vector_size_t>(
+          tempOutputRowMapping_, outputTableRows_.size(), pool());
+      auto addMiss = [&](auto row) {
+        tempOutputTableRows[numPassed] = nullptr;
+        tempOutputRowMapping[numPassed++] = row;
+      };
+      for (auto i = 0; i < numRows; ++i) {
+        const bool passed = filterPassed(i);
+        noMatchDetector_.advance(rawOutputProbeRowMapping[i], passed, addMiss);
+        if (passed) {
+          tempOutputTableRows[numPassed] = outputTableRows_[i];
+          tempOutputRowMapping[numPassed++] = rawOutputProbeRowMapping[i];
+        }
+      }
+      if (resultIter_->atEnd()) {
+        noMatchDetector_.finish(addMiss);
+      }
+      std::copy(
+          tempOutputTableRows,
+          tempOutputTableRows + numPassed,
+          outputTableRows_.data());
+      std::copy(
+          tempOutputRowMapping,
+          tempOutputRowMapping + numPassed,
+          rawOutputProbeRowMapping);
+    } else {
+      auto addMiss = [&](auto row) {
+        outputTableRows_[numPassed] = nullptr;
+        rawOutputProbeRowMapping[numPassed++] = row;
+      };
+      for (auto i = 0; i < numRows; ++i) {
+        const bool passed = filterPassed(i);
+        noMatchDetector_.advance(rawOutputProbeRowMapping[i], passed, addMiss);
+        if (passed) {
+          outputTableRows_[numPassed] = outputTableRows_[i];
+          rawOutputProbeRowMapping[numPassed++] = rawOutputProbeRowMapping[i];
+        }
+      }
+      if (resultIter_->atEnd()) {
+        noMatchDetector_.finish(addMiss);
       }
     }
-
-    noMatchDetector_.finishIteration(
-        addMiss, resultIter_->atEnd(), outputTableRows_.size() - numPassed);
   } else if (isLeftSemiFilterJoin(joinType_)) {
     auto addLastMatch = [&](auto row) {
       outputTableRows_[numPassed] = nullptr;
@@ -1442,9 +1497,9 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
         noMatchDetector_.advance(probeRow, filterPassed(i), addMiss);
       }
     }
-
-    noMatchDetector_.finishIteration(
-        addMiss, resultIter_->atEnd(), outputTableRows_.size() - numPassed);
+    if (resultIter_->atEnd()) {
+      noMatchDetector_.finish(addMiss);
+    }
   } else {
     for (auto i = 0; i < numRows; ++i) {
       if (filterPassed(i)) {
@@ -1453,6 +1508,7 @@ int32_t HashProbe::evalFilter(int32_t numRows) {
       }
     }
   }
+  VELOX_CHECK_LE(numPassed, outputTableRows_.size());
   return numPassed;
 }
 
@@ -1938,6 +1994,8 @@ void HashProbe::close() {
   inputSpiller_.reset();
   table_.reset();
   outputRowMapping_.reset();
+  tempOutputRowMapping_.reset();
+  tempOutputTableRows_.reset();
   output_.reset();
   nonSpillInputIndicesBuffer_.reset();
   spillInputIndicesBuffers_.clear();
diff --git a/velox/exec/HashProbe.h b/velox/exec/HashProbe.h
index 79709e2917f0c..ddb310af6bba0 100644
--- a/velox/exec/HashProbe.h
+++ b/velox/exec/HashProbe.h
@@ -430,12 +430,20 @@ class HashProbe : public Operator {
   // Row number in 'input_' for each output row.
   BufferPtr outputRowMapping_;
 
+  // For left join with filter, we could overwrite the row which we have not
+  // checked if there is a carryover.  Use a temporary buffer in this case.
+  BufferPtr tempOutputRowMapping_;
+
   // maps from column index in 'table_' to channel in 'output_'.
   std::vector<IdentityProjection> tableOutputProjections_;
 
   // Rows of table found by join probe, later filtered by 'filter_'.
   std::vector<char*> outputTableRows_;
 
+  // For left join with filter, we could overwrite the row which we have not
+  // checked if there is a carryover.  Use a temporary buffer in this case.
+  BufferPtr tempOutputTableRows_;
+
   // Indicates probe-side rows which should produce a NULL in left semi project
   // with filter.
   SelectivityVector leftSemiProjectIsNull_;
@@ -447,89 +455,40 @@ class HashProbe : public Operator {
     // Called for each row that the filter was evaluated on. Expects that probe
     // side rows with multiple matches on the build side are next to each other.
     template <typename TOnMiss>
-    void advance(vector_size_t row, bool passed, TOnMiss onMiss) {
-      if (currentRow != row) {
-        // Check if 'currentRow' is the same input row as the last missed row
-        // from a previous output batch.  If so finishIteration will call
-        // onMiss.
-        if (currentRow != -1 && !currentRowPassed &&
-            (!lastMissedRow || currentRow != lastMissedRow)) {
-          onMiss(currentRow);
+    void advance(vector_size_t row, bool passed, TOnMiss&& onMiss) {
+      if (currentRow_ != row) {
+        if (hasLastMissedRow()) {
+          onMiss(currentRow_);
         }
-        currentRow = row;
-        currentRowPassed = false;
+        currentRow_ = row;
+        currentRowPassed_ = false;
       }
-
       if (passed) {
-        // lastMissedRow can only be a row that has never passed the filter.  If
-        // it passes there's no need to continue carrying it forward.
-        if (lastMissedRow && currentRow == lastMissedRow) {
-          lastMissedRow.reset();
-        }
-
-        currentRowPassed = true;
+        currentRowPassed_ = true;
       }
     }
 
-    // Invoked at the end of one output batch processing. 'end' is set to true
-    // at the end of processing an input batch. 'freeOutputRows' is the number
-    // of rows that can still be written to the output batch.
+    // Invoked at the end of all output batches.
     template <typename TOnMiss>
-    void
-    finishIteration(TOnMiss onMiss, bool endOfData, size_t freeOutputRows) {
-      if (endOfData) {
-        if (!currentRowPassed && currentRow != -1) {
-          // If we're at the end of the input batch and the current row hasn't
-          // passed the filter, it never will, process it as a miss.
-          // We're guaranteed to have space, at least the last row was never
-          // written out since it was a miss.
-          onMiss(currentRow);
-          freeOutputRows--;
-        }
-
-        // We no longer need to carry the current row since we already called
-        // onMiss on it.
-        if (lastMissedRow && currentRow == lastMissedRow) {
-          lastMissedRow.reset();
-        }
-
-        currentRow = -1;
-        currentRowPassed = false;
-      }
-
-      // If there's space left in the output batch, write out the last missed
-      // row.
-      if (lastMissedRow && currentRow != lastMissedRow && freeOutputRows > 0) {
-        onMiss(*lastMissedRow);
-        lastMissedRow.reset();
-      }
-
-      // If the current row hasn't passed the filter, we need to carry it
-      // forward in case it never passes the filter.
-      if (!currentRowPassed && currentRow != -1) {
-        lastMissedRow = currentRow;
+    void finish(TOnMiss&& onMiss) {
+      if (hasLastMissedRow()) {
+        onMiss(currentRow_);
       }
+      currentRow_ = -1;
     }
 
     // Returns if we're carrying forward a missed input row. Notably, if this is
     // true, we're not yet done processing the input batch.
-    bool hasLastMissedRow() {
-      return lastMissedRow.has_value();
+    bool hasLastMissedRow() const {
+      return currentRow_ != -1 && !currentRowPassed_;
     }
 
    private:
     // Row number being processed.
-    vector_size_t currentRow{-1};
+    vector_size_t currentRow_{-1};
 
-    // True if currentRow has a match.
-    bool currentRowPassed{false};
-
-    // If set, it points to the last missed (input) row carried over from
-    // previous output batch processing. The last missed row is either written
-    // as a passed row if the same input row has a hit in the next output batch
-    // processed or written to the first output batch which has space at
-    // the end if it never has a hit.
-    std::optional<vector_size_t> lastMissedRow;
+    // True if currentRow_ has a match.
+    bool currentRowPassed_{false};
   };
 
   // For left semi join filter with extra filter, de-duplicates probe side rows
diff --git a/velox/exec/tests/HashJoinTest.cpp b/velox/exec/tests/HashJoinTest.cpp
index 37601f0f913c3..c07d462e5fd0c 100644
--- a/velox/exec/tests/HashJoinTest.cpp
+++ b/velox/exec/tests/HashJoinTest.cpp
@@ -6627,6 +6627,48 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
   test("t_k2 != 4 and t_k2 != 8");
 }
 
+TEST_F(HashJoinTest, leftJoinPreserveProbeOrder) {
+  const std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector(
+          {"k1", "v1"},
+          {
+              makeConstant<int64_t>(0, 2),
+              makeFlatVector<int64_t>({1, 0}),
+          }),
+  };
+  const std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector(
+          {"k2", "v2"},
+          {
+              makeConstant<int64_t>(0, 2),
+              makeConstant<int64_t>(0, 2),
+          }),
+  };
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values(probeVectors)
+          .hashJoin(
+              {"k1"},
+              {"k2"},
+              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+              "v1 % 2 = v2 % 2",
+              {"v1"},
+              core::JoinType::kLeft)
+          .planNode();
+  auto result = AssertQueryBuilder(plan)
+                    .config(core::QueryConfig::kPreferredOutputBatchRows, "1")
+                    .singleThreaded(true)
+                    .copyResults(pool_.get());
+  ASSERT_EQ(result->size(), 3);
+  auto* v1 =
+      result->childAt(0)->loadedVector()->asUnchecked<SimpleVector<int64_t>>();
+  ASSERT_FALSE(v1->mayHaveNulls());
+  ASSERT_EQ(v1->valueAt(0), 1);
+  ASSERT_EQ(v1->valueAt(1), 0);
+  ASSERT_EQ(v1->valueAt(2), 0);
+}
+
 DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());

From c74b5e19e48f5889da84c746d77bafa0109146cb Mon Sep 17 00:00:00 2001
From: xiaoxmeng <xiaoxmeng@fb.com>
Date: Mon, 26 Aug 2024 18:17:53 -0700
Subject: [PATCH 22/24] Relax the reclaimed bytes check for hash build (#10833)

Summary:
Join fuzzer detects check failure on hash build operator reclaim as the operator memory usage gets increased after reclamation. This happens when the parallel join build is running at a background and the memory reclamation is
skipped. The parallel join build can cause additional memory usage such as data structure used to store parallel join
data partitioning as well as duplicate row vector. This PR fixes this by skipping the reclaimed bytes check for hash
build which only use the spill memory pool for memory reclamation.

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10833

Test Plan: This PR has run through join fuzzer in opt mode for 5 hours.

Reviewed By: Yuhta

Differential Revision: D61800038

Pulled By: xiaoxmeng

fbshipit-source-id: 3135e6d908082598b4afe7e52efbb85611b57f60
---
 velox/exec/HashTable.cpp    | 23 +++++++++++------------
 velox/exec/HashTable.h      |  2 +-
 velox/exec/Operator.cpp     | 32 +++++++++++++++++++++++---------
 velox/exec/RowContainer.cpp |  3 ++-
 4 files changed, 37 insertions(+), 23 deletions(-)

diff --git a/velox/exec/HashTable.cpp b/velox/exec/HashTable.cpp
index 7c263dfdd073f..d5d9059461b2a 100644
--- a/velox/exec/HashTable.cpp
+++ b/velox/exec/HashTable.cpp
@@ -1052,7 +1052,7 @@ void HashTable<ignoreNullKeys>::buildJoinPartition(
       buildPartitionBounds_[partition],
       buildPartitionBounds_[partition + 1],
       overflow};
-  auto rowContainer =
+  auto* rowContainer =
       (partition == 0 ? this : otherTables_[partition - 1].get())->rows();
   for (auto i = 0; i < numPartitions; ++i) {
     auto* table = i == 0 ? this : otherTables_[i - 1].get();
@@ -1138,16 +1138,16 @@ void HashTable<ignoreNullKeys>::insertForGroupBy(
 
 template <bool ignoreNullKeys>
 bool HashTable<ignoreNullKeys>::arrayPushRow(char* row, int32_t index) {
-  auto existing = table_[index];
-  if (existing) {
-    if (nextOffset_) {
+  auto* existingRow = table_[index];
+  if (existingRow != nullptr) {
+    if (nextOffset_ > 0) {
       hasDuplicates_ = true;
-      rows_->appendNextRow(existing, row);
+      rows_->appendNextRow(existingRow, row);
     }
     return false;
   }
   table_[index] = row;
-  return !existing;
+  return existingRow == nullptr;
 }
 
 template <bool ignoreNullKeys>
@@ -1155,10 +1155,9 @@ void HashTable<ignoreNullKeys>::pushNext(
     RowContainer* rows,
     char* row,
     char* next) {
-  if (nextOffset_ > 0) {
-    hasDuplicates_ = true;
-    rows->appendNextRow(row, next);
-  }
+  VELOX_CHECK_GT(nextOffset_, 0);
+  hasDuplicates_ = true;
+  rows->appendNextRow(row, next);
 }
 
 template <bool ignoreNullKeys>
@@ -1187,7 +1186,7 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::buildFullProbe(
         [&](char* group, int32_t /*row*/) {
           if (RowContainer::normalizedKey(group) ==
               RowContainer::normalizedKey(inserted)) {
-            if (nextOffset_) {
+            if (nextOffset_ > 0) {
               pushNext(rows, group, inserted);
             }
             return true;
@@ -1809,7 +1808,7 @@ int32_t HashTable<ignoreNullKeys>::listJoinResults(
           (joinProjectedVarColumnsSize(iter.varSizeListColumns, hit) +
            iter.fixedSizeListColumnsSizeSum);
     } else {
-      auto numRows = rows->size();
+      const auto numRows = rows->size();
       auto num =
           std::min(numRows - iter.lastDuplicateRowIndex, maxOut - numOut);
       std::fill_n(inputRows.begin() + numOut, num, row);
diff --git a/velox/exec/HashTable.h b/velox/exec/HashTable.h
index b545658ac6190..4d6293b82b6c0 100644
--- a/velox/exec/HashTable.h
+++ b/velox/exec/HashTable.h
@@ -1002,7 +1002,7 @@ class HashTable : public BaseHashTable {
   std::atomic<bool> hasDuplicates_{false};
 
   // Offset of next row link for join build side set from 'rows_'.
-  int32_t nextOffset_;
+  int32_t nextOffset_{0};
   char** table_ = nullptr;
   memory::ContiguousAllocation tableAllocation_;
 
diff --git a/velox/exec/Operator.cpp b/velox/exec/Operator.cpp
index 0eacee7ca4a89..5abd3e8acda8a 100644
--- a/velox/exec/Operator.cpp
+++ b/velox/exec/Operator.cpp
@@ -304,25 +304,29 @@ void Operator::recordSpillStats() {
     lockedStats->addRuntimeStat(
         kSpillFillTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillFillTimeNanos)});
+            static_cast<int64_t>(lockedSpillStats->spillFillTimeNanos),
+            RuntimeCounter::Unit::kNanos});
   }
   if (lockedSpillStats->spillSortTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillSortTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillSortTimeNanos)});
+            static_cast<int64_t>(lockedSpillStats->spillSortTimeNanos),
+            RuntimeCounter::Unit::kNanos});
   }
   if (lockedSpillStats->spillSerializationTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillSerializationTime,
-        RuntimeCounter{static_cast<int64_t>(
-            lockedSpillStats->spillSerializationTimeNanos)});
+        RuntimeCounter{
+            static_cast<int64_t>(lockedSpillStats->spillSerializationTimeNanos),
+            RuntimeCounter::Unit::kNanos});
   }
   if (lockedSpillStats->spillFlushTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillFlushTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillFlushTimeNanos)});
+            static_cast<int64_t>(lockedSpillStats->spillFlushTimeNanos),
+            RuntimeCounter::Unit::kNanos});
   }
   if (lockedSpillStats->spillWrites != 0) {
     lockedStats->addRuntimeStat(
@@ -333,7 +337,8 @@ void Operator::recordSpillStats() {
     lockedStats->addRuntimeStat(
         kSpillWriteTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillWriteTimeNanos)});
+            static_cast<int64_t>(lockedSpillStats->spillWriteTimeNanos),
+            RuntimeCounter::Unit::kNanos});
   }
   if (lockedSpillStats->spillRuns != 0) {
     lockedStats->addRuntimeStat(
@@ -369,14 +374,17 @@ void Operator::recordSpillStats() {
     lockedStats->addRuntimeStat(
         kSpillReadTime,
         RuntimeCounter{
-            static_cast<int64_t>(lockedSpillStats->spillReadTimeNanos)});
+            static_cast<int64_t>(lockedSpillStats->spillReadTimeNanos),
+            RuntimeCounter::Unit::kNanos});
   }
 
   if (lockedSpillStats->spillDeserializationTimeNanos != 0) {
     lockedStats->addRuntimeStat(
         kSpillDeserializationTime,
-        RuntimeCounter{static_cast<int64_t>(
-            lockedSpillStats->spillDeserializationTimeNanos)});
+        RuntimeCounter{
+            static_cast<int64_t>(
+                lockedSpillStats->spillDeserializationTimeNanos),
+            RuntimeCounter::Unit::kNanos});
   }
   lockedSpillStats->reset();
 }
@@ -648,6 +656,12 @@ uint64_t Operator::MemoryReclaimer::reclaim(
           memory::ScopedReclaimedBytesRecorder recoder(pool, &reclaimedBytes);
           op_->reclaim(targetBytes, stats);
         }
+        // NOTE: the parallel hash build is running at the background thread
+        // pool which won't stop during memory reclamation so the operator's
+        // memory usage might increase in such case. memory usage.
+        if (op_->operatorType() == "HashBuild") {
+          reclaimedBytes = std::max<int64_t>(0, reclaimedBytes);
+        }
         return reclaimedBytes;
       },
       stats);
diff --git a/velox/exec/RowContainer.cpp b/velox/exec/RowContainer.cpp
index 7b8a36ed46ac4..29de71ba6180c 100644
--- a/velox/exec/RowContainer.cpp
+++ b/velox/exec/RowContainer.cpp
@@ -391,8 +391,9 @@ int32_t RowContainer::findRows(folly::Range<char**> rows, char** result) {
 }
 
 void RowContainer::appendNextRow(char* current, char* nextRow) {
+  VELOX_CHECK(getNextRowVector(nextRow) == nullptr);
   NextRowVector*& nextRowArrayPtr = getNextRowVector(current);
-  if (!nextRowArrayPtr) {
+  if (nextRowArrayPtr == nullptr) {
     nextRowArrayPtr =
         new (stringAllocator_->allocate(kNextRowVectorSize)->begin())
             NextRowVector(StlAllocator<char*>(stringAllocator_.get()));

From 72c4921d2a7ef00355530ec59dfbf4ec601aff62 Mon Sep 17 00:00:00 2001
From: Serge Druzkin <sdruzkin@meta.com>
Date: Mon, 26 Aug 2024 20:37:54 -0700
Subject: [PATCH 23/24] Fix minor doc typos in SelectiveColumnReader.h (#10835)

Summary: Pull Request resolved: https://github.com/facebookincubator/velox/pull/10835

Reviewed By: xiaoxmeng, Yuhta

Differential Revision: D61815649

fbshipit-source-id: 20e11fd6dc1a19c249b52884dd26cdef156d4b21
---
 velox/dwio/common/SelectiveColumnReader.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/velox/dwio/common/SelectiveColumnReader.h b/velox/dwio/common/SelectiveColumnReader.h
index e1190f19f1f38..821498a409f4f 100644
--- a/velox/dwio/common/SelectiveColumnReader.h
+++ b/velox/dwio/common/SelectiveColumnReader.h
@@ -105,14 +105,14 @@ struct ScanState {
   DictionaryValues dictionary;
 
   // If the format, like ORC/DWRF has a base dictionary completed by
-  // local delta dictionaries over the furst one, this represents the
+  // local delta dictionaries over the first one, this represents the
   // local values, e.g. row group dictionary in ORC. TBD: If there is
   // a pattern of dictionaries completed by more dictionaries in other
   // formats, this will be modeled as an vector of n DictionaryValues.
   DictionaryValues dictionary2;
 
   // Bits selecting between dictionary and dictionary2 or dictionary and
-  // literal. OR/DWRFC only.
+  // literal. ORC/DWRF only.
   BufferPtr inDictionary;
 
   // Copy of Visitor::rows_ adjusted to start at the current encoding

From 763c19c0c767035ce03573ca2dc852b1303eeb6f Mon Sep 17 00:00:00 2001
From: duanmeng <macduan@tencent.com>
Date: Tue, 27 Aug 2024 02:47:41 -0700
Subject: [PATCH 24/24] Trace metadata during task creation (#10815)

Summary:
Create a directory named `$QueryTraceBaseDir/$taskId` when a task is initiated,
if query tracing is enabled. This directory will store metadata related to the task,
including the query plan node tree, query configurations, and connector properties.

Part of https://github.com/facebookincubator/velox/issues/9668

Pull Request resolved: https://github.com/facebookincubator/velox/pull/10815

Reviewed By: Yuhta

Differential Revision: D61808438

Pulled By: xiaoxmeng

fbshipit-source-id: 57eff8f4b70405ba5c60fcd8315b025b22c2317b
---
 velox/common/memory/Memory.cpp                |   5 +
 velox/common/memory/Memory.h                  |   9 +
 .../common/memory/tests/MemoryManagerTest.cpp |  63 +++----
 velox/core/QueryConfig.h                      |  25 +++
 velox/docs/configs.rst                        |  25 +++
 velox/exec/Task.cpp                           |  42 ++++-
 velox/exec/Task.h                             |  10 ++
 velox/exec/trace/CMakeLists.txt               |  16 +-
 velox/exec/trace/QueryDataReader.cpp          |   3 -
 velox/exec/trace/QueryDataWriter.cpp          |   2 -
 velox/exec/trace/QueryMetadataReader.cpp      |   4 -
 velox/exec/trace/QueryMetadataWriter.cpp      |   3 -
 velox/exec/trace/QueryTraceConfig.cpp         |   5 +
 velox/exec/trace/QueryTraceConfig.h           |   6 +-
 velox/exec/trace/QueryTraceUtil.cpp           |  38 ++++
 velox/exec/trace/QueryTraceUtil.h             |  26 +++
 velox/exec/trace/test/CMakeLists.txt          |   9 +-
 velox/exec/trace/test/QueryTraceTest.cpp      | 166 ++++++++++++++++++
 18 files changed, 405 insertions(+), 52 deletions(-)
 create mode 100644 velox/exec/trace/QueryTraceUtil.cpp
 create mode 100644 velox/exec/trace/QueryTraceUtil.h

diff --git a/velox/common/memory/Memory.cpp b/velox/common/memory/Memory.cpp
index 15213843b7a2a..c42b3912b9806 100644
--- a/velox/common/memory/Memory.cpp
+++ b/velox/common/memory/Memory.cpp
@@ -157,6 +157,7 @@ MemoryManager::MemoryManager(const MemoryManagerOptions& options)
               .coreOnAllocationFailureEnabled =
                   options.coreOnAllocationFailureEnabled})},
       spillPool_{addLeafPool("__sys_spilling__")},
+      tracePool_{addLeafPool("__sys_tracing__")},
       sharedLeafPools_(createSharedLeafMemoryPools(*sysRoot_)) {
   VELOX_CHECK_NOT_NULL(allocator_);
   VELOX_CHECK_NOT_NULL(arbitrator_);
@@ -427,4 +428,8 @@ memory::MemoryPool* spillMemoryPool() {
 bool isSpillMemoryPool(memory::MemoryPool* pool) {
   return pool == spillMemoryPool();
 }
+
+memory::MemoryPool* traceMemoryPool() {
+  return memory::MemoryManager::getInstance()->tracePool();
+}
 } // namespace facebook::velox::memory
diff --git a/velox/common/memory/Memory.h b/velox/common/memory/Memory.h
index ac1085f473bfd..ac176fb2f5bde 100644
--- a/velox/common/memory/Memory.h
+++ b/velox/common/memory/Memory.h
@@ -342,6 +342,11 @@ class MemoryManager {
     return spillPool_.get();
   }
 
+  /// Returns the process wide leaf memory pool used for query tracing.
+  MemoryPool* tracePool() const {
+    return tracePool_.get();
+  }
+
   const std::vector<std::shared_ptr<MemoryPool>>& testingSharedLeafPools() {
     return sharedLeafPools_;
   }
@@ -374,6 +379,7 @@ class MemoryManager {
 
   const std::shared_ptr<MemoryPool> sysRoot_;
   const std::shared_ptr<MemoryPool> spillPool_;
+  const std::shared_ptr<MemoryPool> tracePool_;
   const std::vector<std::shared_ptr<MemoryPool>> sharedLeafPools_;
 
   mutable folly::SharedMutex mutex_;
@@ -420,6 +426,9 @@ memory::MemoryPool* spillMemoryPool();
 /// Returns true if the provided 'pool' is the spilling memory pool.
 bool isSpillMemoryPool(memory::MemoryPool* pool);
 
+/// Returns the system-wide memory pool for tracing memory usage.
+memory::MemoryPool* traceMemoryPool();
+
 FOLLY_ALWAYS_INLINE int32_t alignmentPadding(void* address, int32_t alignment) {
   auto extra = reinterpret_cast<uintptr_t>(address) % alignment;
   return extra == 0 ? 0 : alignment - extra;
diff --git a/velox/common/memory/tests/MemoryManagerTest.cpp b/velox/common/memory/tests/MemoryManagerTest.cpp
index 02ac9a11fb2ab..d3da086e9b86c 100644
--- a/velox/common/memory/tests/MemoryManagerTest.cpp
+++ b/velox/common/memory/tests/MemoryManagerTest.cpp
@@ -53,7 +53,7 @@ TEST_F(MemoryManagerTest, ctor) {
   const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools;
   {
     MemoryManager manager{};
-    ASSERT_EQ(manager.numPools(), 1);
+    ASSERT_EQ(manager.numPools(), 2);
     ASSERT_EQ(manager.capacity(), kMaxMemory);
     ASSERT_EQ(0, manager.getTotalBytes());
     ASSERT_EQ(manager.alignment(), MemoryAllocator::kMaxAlignment);
@@ -69,7 +69,7 @@ TEST_F(MemoryManagerTest, ctor) {
          .arbitratorCapacity = kCapacity,
          .arbitratorReservedCapacity = 0}};
     ASSERT_EQ(kCapacity, manager.capacity());
-    ASSERT_EQ(manager.numPools(), 1);
+    ASSERT_EQ(manager.numPools(), 2);
     ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
   }
   {
@@ -84,7 +84,7 @@ TEST_F(MemoryManagerTest, ctor) {
     ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
     // TODO: replace with root pool memory tracker quota check.
     ASSERT_EQ(
-        kSharedPoolCount + 1, manager.testingDefaultRoot().getChildCount());
+        kSharedPoolCount + 2, manager.testingDefaultRoot().getChildCount());
     ASSERT_EQ(kCapacity, manager.capacity());
     ASSERT_EQ(0, manager.getTotalBytes());
   }
@@ -103,7 +103,7 @@ TEST_F(MemoryManagerTest, ctor) {
     ASSERT_EQ(
         manager.toString(),
         "Memory Manager[capacity 4.00GB alignment 64B usedBytes 0B number of "
-        "pools 1\nList of root pools:\n\t__sys_root__\n"
+        "pools 2\nList of root pools:\n\t__sys_root__\n"
         "Memory Allocator[MALLOC capacity 4.00GB allocated bytes 0 "
         "allocated pages 0 mapped pages 0]\n"
         "ARBITRATOR[SHARED CAPACITY[4.00GB] PENDING[0] "
@@ -246,10 +246,10 @@ TEST_F(MemoryManagerTest, addPoolWithArbitrator) {
 TEST_F(MemoryManagerTest, defaultMemoryManager) {
   auto& managerA = toMemoryManager(deprecatedDefaultMemoryManager());
   auto& managerB = toMemoryManager(deprecatedDefaultMemoryManager());
-  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 1;
-  ASSERT_EQ(managerA.numPools(), 1);
+  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 2;
+  ASSERT_EQ(managerA.numPools(), 2);
   ASSERT_EQ(managerA.testingDefaultRoot().getChildCount(), kSharedPoolCount);
-  ASSERT_EQ(managerB.numPools(), 1);
+  ASSERT_EQ(managerB.numPools(), 2);
   ASSERT_EQ(managerB.testingDefaultRoot().getChildCount(), kSharedPoolCount);
 
   auto child1 = managerA.addLeafPool("child_1");
@@ -260,41 +260,44 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
       kSharedPoolCount + 2, managerA.testingDefaultRoot().getChildCount());
   EXPECT_EQ(
       kSharedPoolCount + 2, managerB.testingDefaultRoot().getChildCount());
-  ASSERT_EQ(managerA.numPools(), 3);
-  ASSERT_EQ(managerB.numPools(), 3);
-  auto pool = managerB.addRootPool();
   ASSERT_EQ(managerA.numPools(), 4);
   ASSERT_EQ(managerB.numPools(), 4);
+  auto pool = managerB.addRootPool();
+  ASSERT_EQ(managerA.numPools(), 5);
+  ASSERT_EQ(managerB.numPools(), 5);
   ASSERT_EQ(
       managerA.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 4\nList of root pools:\n\t__sys_root__\n\tdefault_root_0\n\trefcount 2\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 5\nList of root pools:\n\t__sys_root__\n\tdefault_root_0\n\trefcount 2\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
   ASSERT_EQ(
       managerB.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 4\nList of root pools:\n\t__sys_root__\n\tdefault_root_0\n\trefcount 2\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 5\nList of root pools:\n\t__sys_root__\n\tdefault_root_0\n\trefcount 2\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
   child1.reset();
   EXPECT_EQ(
       kSharedPoolCount + 1, managerA.testingDefaultRoot().getChildCount());
   child2.reset();
   EXPECT_EQ(kSharedPoolCount, managerB.testingDefaultRoot().getChildCount());
+  ASSERT_EQ(managerA.numPools(), 3);
+  ASSERT_EQ(managerB.numPools(), 3);
+  pool.reset();
   ASSERT_EQ(managerA.numPools(), 2);
   ASSERT_EQ(managerB.numPools(), 2);
-  pool.reset();
-  ASSERT_EQ(managerA.numPools(), 1);
-  ASSERT_EQ(managerB.numPools(), 1);
   ASSERT_EQ(
       managerA.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 1\nList of root pools:\n\t__sys_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 2\nList of root pools:\n\t__sys_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
   ASSERT_EQ(
       managerB.toString(),
-      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 1\nList of root pools:\n\t__sys_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
+      "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 2\nList of root pools:\n\t__sys_root__\nMemory Allocator[MALLOC capacity UNLIMITED allocated bytes 0 allocated pages 0 mapped pages 0]\nARBIRTATOR[NOOP CAPACITY[UNLIMITED]]]");
   const std::string detailedManagerStr = managerA.toString(true);
   ASSERT_THAT(
       detailedManagerStr,
       testing::HasSubstr(
-          "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 1\nList of root pools:\n__sys_root__ usage 0B reserved 0B peak 0B\n"));
+          "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 2\nList of root pools:\n__sys_root__ usage 0B reserved 0B peak 0B\n"));
   ASSERT_THAT(
       detailedManagerStr,
       testing::HasSubstr("__sys_spilling__ usage 0B reserved 0B peak 0B\n"));
+  ASSERT_THAT(
+      detailedManagerStr,
+      testing::HasSubstr("__sys_tracing__ usage 0B reserved 0B peak 0B\n"));
   for (int i = 0; i < 32; ++i) {
     ASSERT_THAT(
         managerA.toString(true),
@@ -306,7 +309,7 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
 // TODO: remove this test when remove deprecatedAddDefaultLeafMemoryPool.
 TEST(MemoryHeaderTest, addDefaultLeafMemoryPool) {
   auto& manager = toMemoryManager(deprecatedDefaultMemoryManager());
-  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 1;
+  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 2;
   ASSERT_EQ(manager.testingDefaultRoot().getChildCount(), kSharedPoolCount);
   {
     auto poolA = deprecatedAddDefaultLeafMemoryPool();
@@ -361,7 +364,7 @@ TEST_F(MemoryManagerTest, memoryPoolManagement) {
   MemoryManagerOptions options;
   options.alignment = alignment;
   MemoryManager manager{options};
-  ASSERT_EQ(manager.numPools(), 1);
+  ASSERT_EQ(manager.numPools(), 2);
   const int numPools = 100;
   std::vector<std::shared_ptr<MemoryPool>> userRootPools;
   std::vector<std::shared_ptr<MemoryPool>> userLeafPools;
@@ -386,14 +389,14 @@ TEST_F(MemoryManagerTest, memoryPoolManagement) {
   ASSERT_FALSE(rootUnamedPool->name().empty());
   ASSERT_EQ(rootUnamedPool->kind(), MemoryPool::Kind::kAggregate);
   ASSERT_EQ(rootUnamedPool->parent(), nullptr);
-  ASSERT_EQ(manager.numPools(), 1 + numPools + 2);
+  ASSERT_EQ(manager.numPools(), 1 + numPools + 2 + 1);
   userLeafPools.clear();
   leafUnamedPool.reset();
-  ASSERT_EQ(manager.numPools(), 1 + numPools / 2 + 1);
+  ASSERT_EQ(manager.numPools(), 1 + numPools / 2 + 1 + 1);
   userRootPools.clear();
-  ASSERT_EQ(manager.numPools(), 1 + 1);
+  ASSERT_EQ(manager.numPools(), 1 + 2);
   rootUnamedPool.reset();
-  ASSERT_EQ(manager.numPools(), 1);
+  ASSERT_EQ(manager.numPools(), 2);
 }
 
 // TODO: when run sequentially, e.g. `buck run dwio/memory/...`, this has side
@@ -410,7 +413,7 @@ TEST_F(MemoryManagerTest, globalMemoryManager) {
   ASSERT_NE(manager, globalManager);
   ASSERT_EQ(manager, memoryManager());
   auto* managerII = memoryManager();
-  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 1;
+  const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 2;
   {
     auto& rootI = manager->testingDefaultRoot();
     const std::string childIName("some_child");
@@ -444,9 +447,9 @@ TEST_F(MemoryManagerTest, globalMemoryManager) {
     ASSERT_EQ(userRootChild->kind(), MemoryPool::Kind::kAggregate);
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 1);
     ASSERT_EQ(rootII.getChildCount(), kSharedPoolCount + 1);
-    ASSERT_EQ(manager->numPools(), 2 + 1);
+    ASSERT_EQ(manager->numPools(), 2 + 2);
   }
-  ASSERT_EQ(manager->numPools(), 1);
+  ASSERT_EQ(manager->numPools(), 2);
 }
 
 TEST_F(MemoryManagerTest, alignmentOptionCheck) {
@@ -544,9 +547,9 @@ TEST_F(MemoryManagerTest, concurrentPoolAccess) {
   }
   stopCheck = true;
   checkThread.join();
-  ASSERT_EQ(manager.numPools(), pools.size() + 1);
+  ASSERT_EQ(manager.numPools(), pools.size() + 2);
   pools.clear();
-  ASSERT_EQ(manager.numPools(), 1);
+  ASSERT_EQ(manager.numPools(), 2);
 }
 
 TEST_F(MemoryManagerTest, quotaEnforcement) {
@@ -654,7 +657,7 @@ TEST_F(MemoryManagerTest, disableMemoryPoolTracking) {
     ASSERT_EQ(manager.capacity(), 64LL << 20);
     ASSERT_EQ(manager.shrinkPools(), 0);
     // Default 1 system pool with 1 leaf child
-    ASSERT_EQ(manager.numPools(), 1);
+    ASSERT_EQ(manager.numPools(), 2);
 
     VELOX_ASSERT_THROW(
         leaf0->allocate(38LL << 20), "Exceeded memory pool capacity");
diff --git a/velox/core/QueryConfig.h b/velox/core/QueryConfig.h
index 78f51375fa45a..bc1a24976a712 100644
--- a/velox/core/QueryConfig.h
+++ b/velox/core/QueryConfig.h
@@ -346,6 +346,16 @@ class QueryConfig {
   /// derived using micro-benchmarking.
   static constexpr const char* kPrefixSortMinRows = "prefixsort_min_rows";
 
+  /// Enable query tracing flag.
+  static constexpr const char* kQueryTraceEnabled = "query_trace_enabled";
+
+  /// Base dir of a query to store tracing data.
+  static constexpr const char* kQueryTraceDir = "query_trace_dir";
+
+  /// A comma-separated list of plan node ids whose input data will be traced.
+  /// Empty string if only want to trace the query metadata.
+  static constexpr const char* kQueryTraceNodeIds = "query_trace_node_ids";
+
   uint64_t queryMaxMemoryPerNode() const {
     return config::toCapacity(
         get<std::string>(kQueryMaxMemoryPerNode, "0B"),
@@ -611,6 +621,21 @@ class QueryConfig {
     return get<int32_t>(kSpillableReservationGrowthPct, kDefaultPct);
   }
 
+  /// Returns true if query tracing is enabled.
+  bool queryTraceEnabled() const {
+    return get<bool>(kQueryTraceEnabled, false);
+  }
+
+  std::string queryTraceDir() const {
+    // The default query trace dir, empty by default.
+    return get<std::string>(kQueryTraceDir, "");
+  }
+
+  std::string queryTraceNodeIds() const {
+    // The default query trace nodes, empty by default.
+    return get<std::string>(kQueryTraceNodeIds, "");
+  }
+
   bool prestoArrayAggIgnoreNulls() const {
     return get<bool>(kPrestoArrayAggIgnoreNulls, false);
   }
diff --git a/velox/docs/configs.rst b/velox/docs/configs.rst
index cd782b2d763d2..0e4582e1b5c19 100644
--- a/velox/docs/configs.rst
+++ b/velox/docs/configs.rst
@@ -686,4 +686,29 @@ Spark-specific Configuration
        the value of this config can not exceed the default value.
    * - spark.partition_id
      - integer
+     -
      - The current task's Spark partition ID. It's set by the query engine (Spark) prior to task execution.
+
+Tracing
+--------
+.. list-table::
+   :widths: 30 10 10 70
+   :header-rows: 1
+
+   * - Property Name
+     - Type
+     - Default Value
+     - Description
+   * - query_trace_enabled
+     - bool
+     - true
+     - If true, enable query tracing.
+   * - query_trace_dir
+     - string
+     -
+     - The root directory to store the tracing data and metadata for a query.
+   * - query_trace_node_ids
+     - string
+     -
+     - A comma-separated list of plan node ids whose input data will be trace. If it is empty, then we only trace the
+       query metadata which includes the query plan and configs etc.
diff --git a/velox/exec/Task.cpp b/velox/exec/Task.cpp
index 38006f9baf531..3ff2e7321f46d 100644
--- a/velox/exec/Task.cpp
+++ b/velox/exec/Task.cpp
@@ -27,11 +27,11 @@
 #include "velox/exec/HashBuild.h"
 #include "velox/exec/LocalPlanner.h"
 #include "velox/exec/MemoryReclaimer.h"
-#include "velox/exec/Merge.h"
 #include "velox/exec/NestedLoopJoinBuild.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/Task.h"
+#include "velox/exec/trace/QueryTraceUtil.h"
 
 using facebook::velox::common::testutil::TestValue;
 
@@ -293,6 +293,7 @@ Task::Task(
       planFragment_(std::move(planFragment)),
       destination_(destination),
       queryCtx_(std::move(queryCtx)),
+      traceConfig_(maybeMakeTraceConfig()),
       mode_(mode),
       consumerSupplier_(std::move(consumerSupplier)),
       onError_(std::move(onError)),
@@ -304,6 +305,8 @@ Task::Task(
     VELOX_CHECK_NULL(
         dynamic_cast<const folly::InlineLikeExecutor*>(queryCtx_->executor()));
   }
+
+  maybeInitQueryTrace();
 }
 
 Task::~Task() {
@@ -2833,6 +2836,43 @@ std::shared_ptr<ExchangeClient> Task::getExchangeClientLocked(
   return exchangeClients_[pipelineId];
 }
 
+std::optional<trace::QueryTraceConfig> Task::maybeMakeTraceConfig() const {
+  const auto& queryConfig = queryCtx_->queryConfig();
+  if (!queryConfig.queryTraceEnabled()) {
+    return std::nullopt;
+  }
+
+  VELOX_USER_CHECK(
+      !queryConfig.queryTraceDir().empty(),
+      "Query trace enabled but the trace dir is not set");
+
+  const auto queryTraceNodes = queryConfig.queryTraceNodeIds();
+  if (queryTraceNodes.empty()) {
+    return trace::QueryTraceConfig(queryConfig.queryTraceDir());
+  }
+
+  std::vector<std::string> nodes;
+  folly::split(',', queryTraceNodes, nodes);
+  std::unordered_set<std::string> nodeSet(nodes.begin(), nodes.end());
+  VELOX_CHECK_EQ(nodeSet.size(), nodes.size());
+  LOG(INFO) << "Query trace plan node ids: " << queryTraceNodes;
+  return trace::QueryTraceConfig(
+      std::move(nodeSet), queryConfig.queryTraceDir());
+}
+
+void Task::maybeInitQueryTrace() {
+  if (!traceConfig_) {
+    return;
+  }
+
+  const auto traceTaskDir =
+      fmt::format("{}/{}", traceConfig_->queryTraceDir, taskId_);
+  trace::createTraceDirectory(traceTaskDir);
+  const auto queryMetadatWriter = std::make_unique<trace::QueryMetadataWriter>(
+      traceTaskDir, memory::traceMemoryPool());
+  queryMetadatWriter->write(queryCtx_, planFragment_.planNode);
+}
+
 void Task::testingVisitDrivers(const std::function<void(Driver*)>& callback) {
   std::lock_guard<std::timed_mutex> l(mutex_);
   for (int i = 0; i < drivers_.size(); ++i) {
diff --git a/velox/exec/Task.h b/velox/exec/Task.h
index 433df9a0451e5..6a18d3fbcef17 100644
--- a/velox/exec/Task.h
+++ b/velox/exec/Task.h
@@ -23,6 +23,8 @@
 #include "velox/exec/Split.h"
 #include "velox/exec/TaskStats.h"
 #include "velox/exec/TaskStructs.h"
+#include "velox/exec/trace/QueryMetadataWriter.h"
+#include "velox/exec/trace/QueryTraceConfig.h"
 #include "velox/vector/ComplexVector.h"
 
 namespace facebook::velox::exec {
@@ -969,6 +971,13 @@ class Task : public std::enable_shared_from_this<Task> {
   std::shared_ptr<ExchangeClient> getExchangeClientLocked(
       int32_t pipelineId) const;
 
+  // Builds the query trace config.
+  std::optional<trace::QueryTraceConfig> maybeMakeTraceConfig() const;
+
+  // Create a 'QueryMetadtaWriter' to trace the query metadata if the query
+  // trace enabled.
+  void maybeInitQueryTrace();
+
   // The helper class used to maintain 'numCreatedTasks_' and 'numDeletedTasks_'
   // on task construction and destruction.
   class TaskCounter {
@@ -999,6 +1008,7 @@ class Task : public std::enable_shared_from_this<Task> {
   core::PlanFragment planFragment_;
   const int destination_;
   const std::shared_ptr<core::QueryCtx> queryCtx_;
+  const std::optional<trace::QueryTraceConfig> traceConfig_;
 
   // The execution mode of the task. It is enforced that a task can only be
   // executed in a single mode throughout its lifetime
diff --git a/velox/exec/trace/CMakeLists.txt b/velox/exec/trace/CMakeLists.txt
index 532f3ed27f328..f8cc53e08ae4f 100644
--- a/velox/exec/trace/CMakeLists.txt
+++ b/velox/exec/trace/CMakeLists.txt
@@ -12,10 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_query_trace_exec QueryMetadataWriter.cpp QueryTraceConfig.cpp
-                                   QueryDataWriter.cpp)
+velox_add_library(
+  velox_query_trace_exec
+  QueryMetadataWriter.cpp
+  QueryTraceConfig.cpp
+  QueryDataWriter.cpp
+  QueryTraceUtil.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_query_trace_exec
   PRIVATE
     velox_common_io
@@ -26,10 +30,10 @@ target_link_libraries(
     velox_common_base
     velox_presto_serializer)
 
-add_library(velox_query_trace_retrieve QueryDataReader.cpp
-                                       QueryMetadataReader.cpp)
+velox_add_library(velox_query_trace_retrieve QueryDataReader.cpp
+                  QueryMetadataReader.cpp)
 
-target_link_libraries(
+velox_link_libraries(
   velox_query_trace_retrieve
   velox_common_io
   velox_file
diff --git a/velox/exec/trace/QueryDataReader.cpp b/velox/exec/trace/QueryDataReader.cpp
index b234330dd0e53..f0175fe11b367 100644
--- a/velox/exec/trace/QueryDataReader.cpp
+++ b/velox/exec/trace/QueryDataReader.cpp
@@ -17,9 +17,6 @@
 #include "velox/exec/trace/QueryDataReader.h"
 
 #include "velox/common/file/File.h"
-#include "velox/connectors/hive/HiveDataSink.h"
-#include "velox/connectors/hive/TableHandle.h"
-#include "velox/exec/TableWriter.h"
 #include "velox/exec/trace/QueryTraceTraits.h"
 
 namespace facebook::velox::exec::trace {
diff --git a/velox/exec/trace/QueryDataWriter.cpp b/velox/exec/trace/QueryDataWriter.cpp
index 544e7a3d4580f..57dc4284cd10b 100644
--- a/velox/exec/trace/QueryDataWriter.cpp
+++ b/velox/exec/trace/QueryDataWriter.cpp
@@ -18,8 +18,6 @@
 #include "velox/common/base/SpillStats.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/exec/TreeOfLosers.h"
-#include "velox/exec/UnorderedStreamReader.h"
 #include "velox/exec/trace/QueryTraceTraits.h"
 #include "velox/serializers/PrestoSerializer.h"
 
diff --git a/velox/exec/trace/QueryMetadataReader.cpp b/velox/exec/trace/QueryMetadataReader.cpp
index 8843aa49a2ab6..99fe7cc8c4353 100644
--- a/velox/exec/trace/QueryMetadataReader.cpp
+++ b/velox/exec/trace/QueryMetadataReader.cpp
@@ -18,11 +18,7 @@
 
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/connectors/hive/HiveDataSink.h"
-#include "velox/connectors/hive/TableHandle.h"
 #include "velox/core/PlanNode.h"
-#include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TableWriter.h"
 #include "velox/exec/trace/QueryTraceTraits.h"
 
 namespace facebook::velox::exec::trace {
diff --git a/velox/exec/trace/QueryMetadataWriter.cpp b/velox/exec/trace/QueryMetadataWriter.cpp
index beba2e8097469..e14cdb197f446 100644
--- a/velox/exec/trace/QueryMetadataWriter.cpp
+++ b/velox/exec/trace/QueryMetadataWriter.cpp
@@ -17,11 +17,8 @@
 #include "velox/exec/trace/QueryMetadataWriter.h"
 #include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
-#include "velox/connectors/hive/HiveDataSink.h"
-#include "velox/connectors/hive/TableHandle.h"
 #include "velox/core/PlanNode.h"
 #include "velox/core/QueryCtx.h"
-#include "velox/exec/TableWriter.h"
 #include "velox/exec/trace/QueryTraceTraits.h"
 
 namespace facebook::velox::exec::trace {
diff --git a/velox/exec/trace/QueryTraceConfig.cpp b/velox/exec/trace/QueryTraceConfig.cpp
index 2437a632fb432..233226ebccf50 100644
--- a/velox/exec/trace/QueryTraceConfig.cpp
+++ b/velox/exec/trace/QueryTraceConfig.cpp
@@ -24,4 +24,9 @@ QueryTraceConfig::QueryTraceConfig(
     : queryNodes(std::move(_queryNodeIds)),
       queryTraceDir(std::move(_queryTraceDir)) {}
 
+QueryTraceConfig::QueryTraceConfig(std::string _queryTraceDir)
+    : QueryTraceConfig(
+          std::unordered_set<std::string>{},
+          std::move(_queryTraceDir)) {}
+
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceConfig.h b/velox/exec/trace/QueryTraceConfig.h
index 8afcbf22fb53d..0e9c22818c342 100644
--- a/velox/exec/trace/QueryTraceConfig.h
+++ b/velox/exec/trace/QueryTraceConfig.h
@@ -21,15 +21,17 @@
 
 namespace facebook::velox::exec::trace {
 struct QueryTraceConfig {
-  /// Target query trace nodes
+  /// Target query trace nodes.
   std::unordered_set<std::string> queryNodes;
-  /// Base dir of query trace, normmaly it is $prefix/$taskId.
+  /// Base dir of query trace.
   std::string queryTraceDir;
 
   QueryTraceConfig(
       std::unordered_set<std::string> _queryNodeIds,
       std::string _queryTraceDir);
 
+  QueryTraceConfig(std::string _queryTraceDir);
+
   QueryTraceConfig() = default;
 };
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceUtil.cpp b/velox/exec/trace/QueryTraceUtil.cpp
new file mode 100644
index 0000000000000..437d3eee224e5
--- /dev/null
+++ b/velox/exec/trace/QueryTraceUtil.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/exec/trace/QueryTraceUtil.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/file/FileSystems.h"
+
+namespace facebook::velox::exec::trace {
+
+void createTraceDirectory(const std::string& traceDir) {
+  try {
+    const auto fs = filesystems::getFileSystem(traceDir, nullptr);
+    if (fs->exists(traceDir)) {
+      fs->rmdir(traceDir);
+    }
+    fs->mkdir(traceDir);
+  } catch (const std::exception& e) {
+    VELOX_FAIL(
+        "Failed to create trace directory '{}' with error: {}",
+        traceDir,
+        e.what());
+  }
+}
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/QueryTraceUtil.h b/velox/exec/trace/QueryTraceUtil.h
new file mode 100644
index 0000000000000..826aa35283a28
--- /dev/null
+++ b/velox/exec/trace/QueryTraceUtil.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::velox::exec::trace {
+
+/// Creates a directory to store the query trace metdata and data.
+void createTraceDirectory(const std::string& traceDir);
+
+} // namespace facebook::velox::exec::trace
diff --git a/velox/exec/trace/test/CMakeLists.txt b/velox/exec/trace/test/CMakeLists.txt
index 9c4ffe9dd3585..861b5ffb339ad 100644
--- a/velox/exec/trace/test/CMakeLists.txt
+++ b/velox/exec/trace/test/CMakeLists.txt
@@ -28,4 +28,11 @@ target_link_libraries(
   velox_memory
   velox_query_trace_exec
   velox_query_trace_retrieve
-  velox_vector_fuzzer)
+  velox_vector_fuzzer
+  GTest::gtest_main
+  GTest::gmock
+  Folly::folly
+  gflags::gflags
+  glog::glog
+  fmt::fmt
+  ${FILESYSTEM})
diff --git a/velox/exec/trace/test/QueryTraceTest.cpp b/velox/exec/trace/test/QueryTraceTest.cpp
index 765eeccaaf532..8b969cc1b9b65 100644
--- a/velox/exec/trace/test/QueryTraceTest.cpp
+++ b/velox/exec/trace/test/QueryTraceTest.cpp
@@ -28,6 +28,7 @@
 #include "velox/exec/trace/QueryDataWriter.h"
 #include "velox/exec/trace/QueryMetadataReader.h"
 #include "velox/exec/trace/QueryMetadataWriter.h"
+#include "velox/exec/trace/QueryTraceUtil.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -202,4 +203,169 @@ TEST_F(QueryTracerTest, traceMetadata) {
     ASSERT_EQ(actualConnectorConfigs.at(key), expectedConnectorConfigs.at(key));
   }
 }
+
+TEST_F(QueryTracerTest, task) {
+  const auto rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {BIGINT(), SMALLINT(), TINYINT(), VARCHAR(), VARCHAR(), VARCHAR()});
+  std::vector<RowVectorPtr> rows;
+  constexpr auto numBatch = 1;
+  rows.reserve(numBatch);
+  for (auto i = 0; i < numBatch; ++i) {
+    rows.push_back(vectorFuzzer_.fuzzRow(rowType, 2));
+  }
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values(rows, false)
+          .project({"c0", "c1", "c2"})
+          .hashJoin(
+              {"c0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator)
+                  .values(rows, true)
+                  .singleAggregation({"c0", "c1"}, {"min(c2)"})
+                  .project({"c0 AS u0", "c1 AS u1", "a0 AS u2"})
+                  .planNode(),
+              "c0 < 135",
+              {"c0", "c1", "c2"},
+              core::JoinType::kInner)
+          .planNode();
+  const auto expectedResult =
+      AssertQueryBuilder(planNode).maxDrivers(1).copyResults(pool());
+
+  for (const auto& queryTraceNodeIds : {"1,2", ""}) {
+    const auto outputDir = TempDirectoryPath::create();
+    const auto expectedQueryConfigs =
+        std::unordered_map<std::string, std::string>{
+            {core::QueryConfig::kSpillEnabled, "true"},
+            {core::QueryConfig::kSpillNumPartitionBits, "17"},
+            {core::QueryConfig::kQueryTraceEnabled, "true"},
+            {core::QueryConfig::kQueryTraceDir, outputDir->getPath()},
+            {core::QueryConfig::kQueryTraceEnabled, queryTraceNodeIds},
+            {"key1", "value1"},
+        };
+    const auto expectedConnectorProperties =
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{
+            {"test_trace",
+             std::make_shared<config::ConfigBase>(
+                 std::unordered_map<std::string, std::string>{
+                     {"cKey1", "cVal1"}})}};
+    const auto queryCtx = core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig(expectedQueryConfigs),
+        expectedConnectorProperties);
+
+    std::shared_ptr<Task> task;
+    const auto result = AssertQueryBuilder(planNode)
+                            .queryCtx(queryCtx)
+                            .maxDrivers(1)
+                            .copyResults(pool(), task);
+    assertEqualResults({result}, {expectedResult});
+
+    const auto expectedDir =
+        fmt::format("{}/{}", outputDir->getPath(), task->taskId());
+    const auto fs = filesystems::getFileSystem(expectedDir, nullptr);
+    const auto actaulDirs = fs->list(outputDir->getPath());
+    ASSERT_EQ(actaulDirs.size(), 1);
+    ASSERT_EQ(actaulDirs.at(0), expectedDir);
+
+    std::unordered_map<std::string, std::string> acutalQueryConfigs;
+    std::
+        unordered_map<std::string, std::unordered_map<std::string, std::string>>
+            actualConnectorProperties;
+    core::PlanNodePtr actualQueryPlan;
+    auto reader = trace::QueryMetadataReader(expectedDir, pool());
+    reader.read(acutalQueryConfigs, actualConnectorProperties, actualQueryPlan);
+
+    ASSERT_TRUE(isSamePlan(actualQueryPlan, planNode));
+    ASSERT_EQ(acutalQueryConfigs.size(), expectedQueryConfigs.size());
+    for (const auto& [key, value] : acutalQueryConfigs) {
+      ASSERT_EQ(acutalQueryConfigs.at(key), expectedQueryConfigs.at(key));
+    }
+
+    ASSERT_EQ(
+        actualConnectorProperties.size(), expectedConnectorProperties.size());
+    ASSERT_EQ(actualConnectorProperties.count("test_trace"), 1);
+    const auto expectedConnectorConfigs =
+        expectedConnectorProperties.at("test_trace")->rawConfigsCopy();
+    const auto actualConnectorConfigs =
+        actualConnectorProperties.at("test_trace");
+    for (const auto& [key, value] : actualConnectorConfigs) {
+      ASSERT_EQ(
+          actualConnectorConfigs.at(key), expectedConnectorConfigs.at(key));
+    }
+  }
+}
+
+TEST_F(QueryTracerTest, error) {
+  const auto planNode = PlanBuilder().values({}).planNode();
+  const auto expectedQueryConfigs =
+      std::unordered_map<std::string, std::string>{
+          {core::QueryConfig::kSpillEnabled, "true"},
+          {core::QueryConfig::kSpillNumPartitionBits, "17"},
+          {core::QueryConfig::kQueryTraceEnabled, "true"},
+      };
+  const auto queryCtx = core::QueryCtx::create(
+      executor_.get(), core::QueryConfig(expectedQueryConfigs));
+  VELOX_ASSERT_USER_THROW(
+      AssertQueryBuilder(planNode).queryCtx(queryCtx).maxDrivers(1).copyResults(
+          pool()),
+      "Query trace enabled but the trace dir is not set");
+}
+
+TEST_F(QueryTracerTest, traceDir) {
+  const auto outputDir = TempDirectoryPath::create();
+  const auto rootDir = outputDir->getPath();
+  const auto fs = filesystems::getFileSystem(rootDir, nullptr);
+  auto dir1 = fmt::format("{}/{}", outputDir->getPath(), "t1");
+  trace::createTraceDirectory(dir1);
+  ASSERT_TRUE(fs->exists(dir1));
+
+  auto dir2 = fmt::format("{}/{}", dir1, "t1_1");
+  trace::createTraceDirectory(dir2);
+  ASSERT_TRUE(fs->exists(dir2));
+
+  // It will remove the old dir1 along with its subdir when created the dir1
+  // again.
+  trace::createTraceDirectory(dir1);
+  ASSERT_TRUE(fs->exists(dir1));
+  ASSERT_FALSE(fs->exists(dir2));
+
+  const auto parentDir = fmt::format("{}/{}", outputDir->getPath(), "p");
+  fs->mkdir(parentDir);
+
+  constexpr auto numThreads = 5;
+  std::vector<std::thread> queryThreads;
+  queryThreads.reserve(numThreads);
+  std::set<std::string> expectedDirs;
+  for (int i = 0; i < numThreads; ++i) {
+    queryThreads.emplace_back([&, i]() {
+      const auto dir = fmt::format("{}/s{}", parentDir, i);
+      trace::createTraceDirectory(dir);
+      expectedDirs.insert(dir);
+    });
+  }
+
+  for (auto& queryThread : queryThreads) {
+    queryThread.join();
+  }
+
+  const auto actualDirs = fs->list(parentDir);
+  ASSERT_EQ(actualDirs.size(), numThreads);
+  ASSERT_EQ(actualDirs.size(), expectedDirs.size());
+  for (const auto& dir : actualDirs) {
+    ASSERT_EQ(expectedDirs.count(dir), 1);
+  }
+}
 } // namespace facebook::velox::exec::test
+
+// This main is needed for some tests on linux.
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  // Signal handler required for ThreadDebugInfoTest
+  facebook::velox::process::addDefaultFatalSignalHandler();
+  folly::Init init(&argc, &argv, false);
+  return RUN_ALL_TESTS();
+}