From d8eee16a048bafdc309921544b49c75043f63adf Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Thu, 7 May 2026 22:54:33 -0700
Subject: [PATCH 01/10] refactor: rename BlkAllocMetrics to
 VarsizeBlkAllocMetrics

The class was named BlkAllocMetrics but is exclusively used by
VarsizeBlkAllocator and its slab subsystem (SlabMetrics registers to
it as parent). The name is now accurate and leaves room for a separate
FixedBlkAllocMetrics class.
---
 src/engine/blkalloc/blk_cache_queue.cpp      |  6 +++---
 src/engine/blkalloc/blk_cache_queue.h        | 10 +++++-----
 src/engine/blkalloc/test_blk_cache_queue.cpp |  4 ++--
 src/engine/blkalloc/varsize_blk_allocator.h  | 16 ++++++++--------
 4 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/engine/blkalloc/blk_cache_queue.cpp b/src/engine/blkalloc/blk_cache_queue.cpp
index 6af2b23dd..cc134c0ae 100644
--- a/src/engine/blkalloc/blk_cache_queue.cpp
+++ b/src/engine/blkalloc/blk_cache_queue.cpp
@@ -19,7 +19,7 @@
 #include "blk_cache_queue.h"
 
 namespace homestore {
-FreeBlkCacheQueue::FreeBlkCacheQueue(const SlabCacheConfig& cfg, BlkAllocMetrics* const metrics) :
+FreeBlkCacheQueue::FreeBlkCacheQueue(const SlabCacheConfig& cfg, VarsizeBlkAllocMetrics* const metrics) :
         m_cfg{cfg}, m_metrics{metrics} {
 #ifndef NDEBUG
     blk_count_t slab_size{1};
@@ -294,7 +294,7 @@ std::optional< blk_temp_t > FreeBlkCacheQueue::pop_slab(const slab_idx_t slab_id
 }
 
 SlabCacheQueue::SlabCacheQueue(const blk_count_t slab_size, const std::vector< blk_cap_t >& level_limits,
-                               const float refill_pct, BlkAllocMetrics* parent_metrics) :
+                               const float refill_pct, VarsizeBlkAllocMetrics* parent_metrics) :
         m_slab_size{slab_size}, m_metrics{m_slab_size, this, parent_metrics} {
     for (auto& limit : level_limits) {
         auto ptr{std::make_unique< folly::MPMCQueue< blk_cache_entry > >(limit)};
@@ -370,7 +370,7 @@ void SlabCacheQueue::close_session(const uint64_t session_id) {
     m_refill_session.compare_exchange_strong(expected_session_id, 0, std::memory_order_acq_rel);
 }
 
-SlabMetrics::SlabMetrics(const blk_count_t slab_size, SlabCacheQueue* const slab_queue, BlkAllocMetrics* const parent) :
+SlabMetrics::SlabMetrics(const blk_count_t slab_size, SlabCacheQueue* const slab_queue, VarsizeBlkAllocMetrics* const parent) :
         sisl::MetricsGroup{"SlabMetrics", fmt::format("{}_slab_{:03d}", parent->instance_name(), slab_size)},
         m_slab_queue{slab_queue} {
     REGISTER_COUNTER(num_slab_alloc, "Number of alloc attempts in this slab");
diff --git a/src/engine/blkalloc/blk_cache_queue.h b/src/engine/blkalloc/blk_cache_queue.h
index b00b6e13d..5ec38d997 100644
--- a/src/engine/blkalloc/blk_cache_queue.h
+++ b/src/engine/blkalloc/blk_cache_queue.h
@@ -29,10 +29,10 @@
 namespace homestore {
 
 class SlabCacheQueue;
-class BlkAllocMetrics;
+class VarsizeBlkAllocMetrics;
 class SlabMetrics : public sisl::MetricsGroup {
 public:
-    SlabMetrics(const blk_count_t slab_size, SlabCacheQueue* const slab_queue, BlkAllocMetrics* const parent);
+    SlabMetrics(const blk_count_t slab_size, SlabCacheQueue* const slab_queue, VarsizeBlkAllocMetrics* const parent);
     SlabMetrics(const SlabMetrics&) = delete;
     SlabMetrics(SlabMetrics&&) noexcept = delete;
     SlabMetrics& operator=(const SlabMetrics&) = delete;
@@ -48,7 +48,7 @@ class SlabMetrics : public sisl::MetricsGroup {
 class SlabCacheQueue {
 public:
     SlabCacheQueue(const blk_count_t slab_size, const std::vector< blk_cap_t >& level_limits, const float refill_pct,
-                   BlkAllocMetrics* metrics);
+                   VarsizeBlkAllocMetrics* metrics);
     SlabCacheQueue(const SlabCacheQueue&) = delete;
     SlabCacheQueue(SlabCacheQueue&&) noexcept = delete;
     SlabCacheQueue& operator=(const SlabCacheQueue&) = delete;
@@ -82,7 +82,7 @@ class SlabCacheQueue {
 
 class FreeBlkCacheQueue : public FreeBlkCache {
 public:
-    FreeBlkCacheQueue(const SlabCacheConfig& cfg, BlkAllocMetrics* metrics);
+    FreeBlkCacheQueue(const SlabCacheConfig& cfg, VarsizeBlkAllocMetrics* metrics);
     virtual ~FreeBlkCacheQueue() override = default;
     FreeBlkCacheQueue(FreeBlkCacheQueue&&) noexcept = delete;
     FreeBlkCacheQueue& operator=(const FreeBlkCacheQueue&) = delete;
@@ -121,7 +121,7 @@ class FreeBlkCacheQueue : public FreeBlkCache {
 private:
     std::vector< std::unique_ptr< SlabCacheQueue > > m_slab_queues;
     SlabCacheConfig m_cfg;
-    BlkAllocMetrics* m_metrics;
+    VarsizeBlkAllocMetrics* m_metrics;
 };
 
 } // namespace homestore
diff --git a/src/engine/blkalloc/test_blk_cache_queue.cpp b/src/engine/blkalloc/test_blk_cache_queue.cpp
index 622fcdaf7..64565d77a 100644
--- a/src/engine/blkalloc/test_blk_cache_queue.cpp
+++ b/src/engine/blkalloc/test_blk_cache_queue.cpp
@@ -34,7 +34,7 @@ SISL_LOGGING_INIT(HOMESTORE_LOG_MODS)
 
 using namespace homestore;
 
-std::unique_ptr< BlkAllocMetrics > g_metrics;
+std::unique_ptr< VarsizeBlkAllocMetrics > g_metrics;
 
 struct BlkCacheQueueTest : public ::testing::Test {
 protected:
@@ -286,7 +286,7 @@ int main(int argc, char* argv[]) {
     sisl::logging::SetLogger("test_blkalloc");
     spdlog::set_pattern("[%D %T%z] [%^%l%$] [%n] [%t] %v");
 
-    g_metrics = std::make_unique< BlkAllocMetrics >("BlkCacheQueueTest");
+    g_metrics = std::make_unique< VarsizeBlkAllocMetrics >("BlkCacheQueueTest");
     const int result{RUN_ALL_TESTS()};
     g_metrics.reset();
     return result;
diff --git a/src/engine/blkalloc/varsize_blk_allocator.h b/src/engine/blkalloc/varsize_blk_allocator.h
index 456902e47..eaa0cf65e 100644
--- a/src/engine/blkalloc/varsize_blk_allocator.h
+++ b/src/engine/blkalloc/varsize_blk_allocator.h
@@ -188,9 +188,9 @@ class BlkAllocSegment {
     [[nodiscard]] seg_num_t get_seg_num() const { return m_seg_num; }
 };
 
-class BlkAllocMetrics : public sisl::MetricsGroup {
+class VarsizeBlkAllocMetrics : public sisl::MetricsGroup {
 public:
-    explicit BlkAllocMetrics(const char* const inst_name) : sisl::MetricsGroup("BlkAlloc", inst_name) {
+    explicit VarsizeBlkAllocMetrics(const char* const inst_name) : sisl::MetricsGroup("VarsizeBlkAlloc", inst_name) {
         REGISTER_COUNTER(num_alloc, "Number of blks alloc attempts");
         REGISTER_COUNTER(num_alloc_failure, "Number of blk alloc failures");
         REGISTER_COUNTER(num_alloc_partial, "Number of blk alloc partial allocations");
@@ -203,11 +203,11 @@ class BlkAllocMetrics : public sisl::MetricsGroup {
         register_me_to_farm();
     }
 
-    BlkAllocMetrics(const BlkAllocMetrics&) = delete;
-    BlkAllocMetrics(BlkAllocMetrics&&) noexcept = delete;
-    BlkAllocMetrics& operator=(const BlkAllocMetrics&) = delete;
-    BlkAllocMetrics& operator=(BlkAllocMetrics&&) noexcept = delete;
-    ~BlkAllocMetrics() { deregister_me_from_farm(); }
+    VarsizeBlkAllocMetrics(const VarsizeBlkAllocMetrics&) = delete;
+    VarsizeBlkAllocMetrics(VarsizeBlkAllocMetrics&&) noexcept = delete;
+    VarsizeBlkAllocMetrics& operator=(const VarsizeBlkAllocMetrics&) = delete;
+    VarsizeBlkAllocMetrics& operator=(VarsizeBlkAllocMetrics&&) noexcept = delete;
+    ~VarsizeBlkAllocMetrics() { deregister_me_from_farm(); }
 };
 
 /* VarsizeBlkAllocator provides a flexibility in allocation. It provides following features:
@@ -270,7 +270,7 @@ class VarsizeBlkAllocator : public BlkAllocator {
     std::shared_ptr< blk_cache_fill_session > m_cur_fill_session; // Cache fill requirements while sweeping
 
     std::uniform_int_distribution< blk_num_t > m_rand_portion_num_generator;
-    BlkAllocMetrics m_metrics;
+    VarsizeBlkAllocMetrics m_metrics;
 
     // TODO: this fields needs to be passed in from hints and persisted in volume's sb;
     blk_num_t m_start_portion_num{INVALID_PORTION_NUM};

From c965d4678d898023247136f234ca0750124e3535 Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Thu, 7 May 2026 23:06:53 -0700
Subject: [PATCH 02/10] feat: add blk_alloc_memory_size gauge to both block
 allocators

FixedBlkAllocMetrics: new metrics class with num_alloc, num_alloc_failure
counters and a blk_alloc_memory_size gauge. Wired into FixedBlkAllocator
constructor; gauge is set once at construction since MPMC queue capacity
is fixed (total_blks x 12B per slot: 6B BlkId + 6B folly sequence field,
confirmed via GDB on 461GB index device = 10.06GB).

VarsizeBlkAllocMetrics: adds the same blk_alloc_memory_size gauge, updated
once after FreeBlkCacheQueue construction via the new total_slab_capacity()
helper (sum of all slab entry_capacity() x 12B per slot = 1.60GB for the
production data blkstore configuration).
---
 src/engine/blkalloc/blk_allocator.h           | 17 +++++++++++++++++
 src/engine/blkalloc/blk_cache_queue.cpp       |  8 ++++++++
 src/engine/blkalloc/blk_cache_queue.h         |  1 +
 src/engine/blkalloc/fixed_blk_allocator.cpp   | 12 ++++++++++--
 src/engine/blkalloc/varsize_blk_allocator.cpp |  5 +++++
 src/engine/blkalloc/varsize_blk_allocator.h   |  1 +
 6 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/src/engine/blkalloc/blk_allocator.h b/src/engine/blkalloc/blk_allocator.h
index 09857b613..4d620a568 100644
--- a/src/engine/blkalloc/blk_allocator.h
+++ b/src/engine/blkalloc/blk_allocator.h
@@ -27,6 +27,7 @@
 
 #include <sisl/fds/bitset.hpp>
 #include <folly/MPMCQueue.h>
+#include <sisl/metrics/metrics.hpp>
 #include <sisl/utility/enum.hpp>
 #include <sisl/utility/urcu_helper.hpp>
 #include <sisl/sobject/sobject.hpp>
@@ -342,6 +343,21 @@ class BlkAllocator {
     std::atomic< bool > is_disk_bm_dirty{true}; // initially disk_bm treated as dirty
 };
 
+class FixedBlkAllocMetrics : public sisl::MetricsGroup {
+public:
+    explicit FixedBlkAllocMetrics(const char* const inst_name) : sisl::MetricsGroup("FixedBlkAlloc", inst_name) {
+        REGISTER_COUNTER(num_alloc, "Number of blks alloc attempts");
+        REGISTER_COUNTER(num_alloc_failure, "Number of blk alloc failures");
+        REGISTER_GAUGE(blk_alloc_memory_size, "Memory used by block allocator internal structures in bytes");
+        register_me_to_farm();
+    }
+    FixedBlkAllocMetrics(const FixedBlkAllocMetrics&) = delete;
+    FixedBlkAllocMetrics(FixedBlkAllocMetrics&&) noexcept = delete;
+    FixedBlkAllocMetrics& operator=(const FixedBlkAllocMetrics&) = delete;
+    FixedBlkAllocMetrics& operator=(FixedBlkAllocMetrics&&) noexcept = delete;
+    ~FixedBlkAllocMetrics() { deregister_me_from_farm(); }
+};
+
 /* FixedBlkAllocator is a fast allocator where it allocates only 1 size block and ALL free blocks are cached instead
  * of selectively caching few blks which are free. Thus there is no sweeping of bitmap or other to refill the cache.
  * It does not support temperature of blocks and allocates simply on first come first serve basis
@@ -372,6 +388,7 @@ class FixedBlkAllocator : public BlkAllocator {
 
 private:
     folly::MPMCQueue< BlkId > m_blk_q;
+    FixedBlkAllocMetrics m_metrics;
 };
 
 } // namespace homestore
diff --git a/src/engine/blkalloc/blk_cache_queue.cpp b/src/engine/blkalloc/blk_cache_queue.cpp
index cc134c0ae..347fad8e5 100644
--- a/src/engine/blkalloc/blk_cache_queue.cpp
+++ b/src/engine/blkalloc/blk_cache_queue.cpp
@@ -176,6 +176,14 @@ blk_cap_t FreeBlkCacheQueue::total_free_blks() const {
     return count;
 }
 
+blk_cap_t FreeBlkCacheQueue::total_slab_capacity() const {
+    blk_cap_t count{0};
+    for (const auto& sq : m_slab_queues) {
+        count += sq->entry_capacity();
+    }
+    return count;
+}
+
 BlkAllocStatus FreeBlkCacheQueue::try_alloc_in_slab(const slab_idx_t slab_idx, const blk_cache_alloc_req& req,
                                                     blk_cache_alloc_resp& resp) {
     if (resp.nblks_alloced >= req.nblks) { return BlkAllocStatus::SUCCESS; }
diff --git a/src/engine/blkalloc/blk_cache_queue.h b/src/engine/blkalloc/blk_cache_queue.h
index 5ec38d997..30137695a 100644
--- a/src/engine/blkalloc/blk_cache_queue.h
+++ b/src/engine/blkalloc/blk_cache_queue.h
@@ -97,6 +97,7 @@ class FreeBlkCacheQueue : public FreeBlkCache {
                                            blk_cache_fill_session& fill_session) override;
 
     [[nodiscard]] blk_cap_t total_free_blks() const override;
+    [[nodiscard]] blk_cap_t total_slab_capacity() const;
 
     [[nodiscard]] std::shared_ptr< blk_cache_fill_session > create_cache_fill_session(const bool fill_entire_cache);
     void close_cache_fill_session(blk_cache_fill_session& fill_session);
diff --git a/src/engine/blkalloc/fixed_blk_allocator.cpp b/src/engine/blkalloc/fixed_blk_allocator.cpp
index 9e8d9d827..6040c5931 100644
--- a/src/engine/blkalloc/fixed_blk_allocator.cpp
+++ b/src/engine/blkalloc/fixed_blk_allocator.cpp
@@ -22,7 +22,10 @@
 
 namespace homestore {
 FixedBlkAllocator::FixedBlkAllocator(const BlkAllocConfig& cfg, const bool init, const chunk_num_t chunk_id) :
-        BlkAllocator(cfg, chunk_id), m_blk_q{cfg.get_total_blks()} {
+        BlkAllocator(cfg, chunk_id), m_blk_q{cfg.get_total_blks()}, m_metrics{cfg.get_name().c_str()} {
+    // folly::MPMCQueue slot for BlkId: 6B item + 6B MPMC sequence field = 12B (confirmed via GDB)
+    static constexpr uint64_t k_mpmc_slot_bytes{12};
+    GAUGE_UPDATE(m_metrics, blk_alloc_memory_size, m_blk_q.capacity() * k_mpmc_slot_bytes);
     LOGINFO("total blks: {}", cfg.get_total_blks());
     if (init) { inited(); }
 }
@@ -72,8 +75,12 @@ BlkAllocStatus FixedBlkAllocator::alloc(const blk_count_t nblks, const blk_alloc
 }
 
 BlkAllocStatus FixedBlkAllocator::alloc(BlkId& out_blkid) {
+    COUNTER_INCREMENT(m_metrics, num_alloc, 1);
 #ifdef _PRERELEASE
-    if (homestore_flip->test_flip("fixed_blkalloc_no_blks")) { return BlkAllocStatus::SPACE_FULL; }
+    if (homestore_flip->test_flip("fixed_blkalloc_no_blks")) {
+        COUNTER_INCREMENT(m_metrics, num_alloc_failure, 1);
+        return BlkAllocStatus::SPACE_FULL;
+    }
 #endif
     const auto ret{m_blk_q.read(out_blkid)};
     if (ret) {
@@ -81,6 +88,7 @@ BlkAllocStatus FixedBlkAllocator::alloc(BlkId& out_blkid) {
         alloc_on_realtime(out_blkid);
         return BlkAllocStatus::SUCCESS;
     } else {
+        COUNTER_INCREMENT(m_metrics, num_alloc_failure, 1);
         return BlkAllocStatus::SPACE_FULL;
     }
 }
diff --git a/src/engine/blkalloc/varsize_blk_allocator.cpp b/src/engine/blkalloc/varsize_blk_allocator.cpp
index 874d4680f..dd7971a0e 100644
--- a/src/engine/blkalloc/varsize_blk_allocator.cpp
+++ b/src/engine/blkalloc/varsize_blk_allocator.cpp
@@ -75,6 +75,11 @@ VarsizeBlkAllocator::VarsizeBlkAllocator(const VarsizeBlkAllocConfig& cfg, const
     if (m_cfg.get_use_slabs()) {
         m_fb_cache = std::make_unique< FreeBlkCacheQueue >(cfg.m_slab_config, &m_metrics);
 
+        // folly::MPMCQueue slot for blk_cache_entry: 6B item + 6B MPMC sequence field = 12B (confirmed via GDB)
+        static constexpr uint64_t k_mpmc_slot_bytes{12};
+        const auto* q{static_cast< FreeBlkCacheQueue* >(m_fb_cache.get())};
+        GAUGE_UPDATE(m_metrics, blk_alloc_memory_size, q->total_slab_capacity() * k_mpmc_slot_bytes);
+
         LOGINFO("m_fb_cache total free blks: {}", m_fb_cache->total_free_blks());
     }
 
diff --git a/src/engine/blkalloc/varsize_blk_allocator.h b/src/engine/blkalloc/varsize_blk_allocator.h
index eaa0cf65e..2ff1cf289 100644
--- a/src/engine/blkalloc/varsize_blk_allocator.h
+++ b/src/engine/blkalloc/varsize_blk_allocator.h
@@ -196,6 +196,7 @@ class VarsizeBlkAllocMetrics : public sisl::MetricsGroup {
         REGISTER_COUNTER(num_alloc_partial, "Number of blk alloc partial allocations");
         REGISTER_COUNTER(num_retries, "Number of times it retried because of empty cache");
         REGISTER_COUNTER(num_blks_alloc_direct, "Number of blks alloc attempt directly because of empty cache");
+        REGISTER_GAUGE(blk_alloc_memory_size, "Memory used by block allocator internal structures in bytes");
 #ifndef NDEBUG
         REGISTER_HISTOGRAM(frag_pct_distribution, "Distribution of fragmentation percentage",
                            HistogramBucketsType(LinearUpto64Buckets));

From 08073a121bca838712103ae9cef69494a6a03ca4 Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Thu, 7 May 2026 23:42:52 -0700
Subject: [PATCH 03/10] fix: account for per-node overhead in cache size
 tracking and eviction
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cache evictor's get_size() callback was returning only m_cache_size (the
raw node data buffer), but each cached entry allocates additional heap memory:

  actual_cost = m_cache_size + sizeof(CacheBufferType)
                             + sizeof(homeds::MemVector)
                             + sizeof(homeds::MemPiece)

This missing overhead caused two interconnected bugs:

1. cache_size metric underreported actual RSS by factor of:
   (m_cache_size + overhead) / m_cache_size

2. Evictor's m_cur_size tracked only m_cache_size, so when m_cur_size
   approached m_max_size, actual RSS was already at:
   m_max_size × (m_cache_size + overhead) / m_cache_size

   This prevented eviction from triggering before OOM.

The fix adds the overhead using compile-time sizeof() for each component,
ensuring both the cache_size gauge and eviction threshold (m_cur_size vs
m_max_size) accurately reflect true memory consumption.

For typical 512B btree nodes: overhead ≈ 320B → multiplier ≈ 1.625×
For larger 4KB nodes: same absolute overhead → multiplier ≈ 1.078×

The formula scales correctly across different node sizes without hardcoding.
---
 src/engine/cache/cache.h | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/engine/cache/cache.h b/src/engine/cache/cache.h
index 41279ceb3..058dbedef 100644
--- a/src/engine/cache/cache.h
+++ b/src/engine/cache/cache.h
@@ -422,7 +422,15 @@ class CacheBuffer : public CacheRecord {
 
     static uint32_t get_size(const CurrentEvictor::EvictRecordType* const rec) {
         const CacheBufferType* cbuf{static_cast< CacheBufferType* >(rec->cache_buffer)};
-        return cbuf->get_cache_size();
+        // Actual memory cost per cached entry includes overhead beyond the raw data buffer:
+        //   sizeof(CacheBufferType): CacheBuffer base class + derived class (e.g., BtreeNode) members
+        //   sizeof(homeds::MemVector): MemVector object holding buffer metadata (80 bytes measured via GDB)
+        //   sizeof(homeds::MemPiece): MemPiece[1] array for contiguous buffer tracking (32 bytes, tcmalloc rounds 18→32)
+        // m_cache_size tracks only the raw data buffer (e.g., 512B or 4096B for btree nodes)
+        // For btree nodes, empirical validation via GDB: 832B total = 512B data + 320B overhead
+        // This formula ensures cache_size metric and eviction threshold reflect true RSS cost
+        static constexpr uint32_t k_overhead{sizeof(CacheBufferType) + sizeof(homeds::MemVector) + sizeof(homeds::MemPiece)};
+        return cbuf->get_cache_size() + k_overhead;
     }
 };
 

From 5989dc1ea7e71a1249a55fda58a7fa926a20afab Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Fri, 8 May 2026 00:27:21 -0700
Subject: [PATCH 04/10] Add iterative verify_node implementation to reduce lock
 contention

Add verify_node_fowarding() using std::queue for iterative tree traversal.
Benefits over recursive verify_node_recursive():
- Reduces lock contention: ancestor nodes unlocked while processing descendants
- Enables cache eviction during traversal: ref_count drops to 1 immediately per node
- Lower peak stack depth for deep trees

This does NOT solve cross-volume cache accumulation during recovery. The actual
OOM fix is force_evict() after each volume completes (separate commit).

Add recursive parameter (default false) to verify_tree() propagated through:
- btree.hpp: verify_tree(update_debug_bm, recursive)
- mapping.hpp/cpp: verify_tree delegation
- volume.hpp/cpp: verify_tree delegation

Dispatcher verify_node() routes to verify_node_recursive() when recursive=true,
verify_node_fowarding() when recursive=false (default).
---
 src/engine/homeds/btree/btree.hpp | 174 ++++++++++++++++++++++++++++--
 src/homeblks/volume/mapping.cpp   |   2 +-
 src/homeblks/volume/mapping.hpp   |   2 +-
 src/homeblks/volume/volume.cpp    |   2 +-
 src/homeblks/volume/volume.hpp    |   2 +-
 5 files changed, 172 insertions(+), 10 deletions(-)

diff --git a/src/engine/homeds/btree/btree.hpp b/src/engine/homeds/btree/btree.hpp
index 9cfb309cf..638a0c0ac 100644
--- a/src/engine/homeds/btree/btree.hpp
+++ b/src/engine/homeds/btree/btree.hpp
@@ -742,11 +742,12 @@ class Btree {
      * @return : true if btree is not corrupted.
      *           false if btree is corrupted;
      */
-    bool verify_tree(bool update_debug_bm) {
+    bool verify_tree(bool update_debug_bm, bool recursive=false) {
         m_btree_lock.read_lock();
-        bool ret = verify_node(m_root_node, nullptr, -1, update_debug_bm);
+		LOGINFO("Starting btree verification for: {}", m_btree_cfg.get_name());
+        bool ret = verify_node(m_root_node, nullptr, -1, update_debug_bm, recursive);
         m_btree_lock.unlock();
-
+		LOGINFO("Completed btree verification for: {}, result={}", m_btree_cfg.get_name(), ret);
         return ret;
     }
 
@@ -1149,6 +1150,13 @@ class Btree {
     nlohmann::json get_metrics_in_json(bool updated = true) { return m_metrics.get_result_in_json(updated); }
 
 private:
+	bool verify_node(bnodeid_t bnodeid, BtreeNodePtr parent_node, uint32_t indx, bool update_debug_bm, bool recursive=false) {
+		if (recursive) {
+            return verify_node_recursive(bnodeid, parent_node, indx, update_debug_bm);
+        } else {
+            return verify_node_fowarding(bnodeid, parent_node, indx, update_debug_bm);
+        }
+	}
     /**
      * @brief : verify the btree node is corrupted or not;
      *
@@ -1162,7 +1170,7 @@ class Btree {
      * @return : true if this node including all its children are not corrupted;
      *           false if not;
      */
-    bool verify_node(bnodeid_t bnodeid, BtreeNodePtr parent_node, uint32_t indx, bool update_debug_bm) {
+    bool verify_node_recursive(bnodeid_t bnodeid, BtreeNodePtr parent_node, uint32_t indx, bool update_debug_bm) {
         homeds::thread::locktype acq_lock = homeds::thread::locktype::LOCKTYPE_READ;
         BtreeNodePtr my_node;
         if (read_and_lock_node(bnodeid, my_node, acq_lock, acq_lock, nullptr) != btree_status_t::success) {
@@ -1183,7 +1191,7 @@ class Btree {
             if (!my_node->is_leaf()) {
                 BtreeNodeInfo child;
                 my_node->get(i, &child, false);
-                success = verify_node(child.bnode_id(), my_node, i, update_debug_bm);
+                success = verify_node_recursive(child.bnode_id(), my_node, i, update_debug_bm);
                 if (!success) { goto exit_on_error; }
 
                 if (i > 0) {
@@ -1261,7 +1269,7 @@ class Btree {
         }
 
         if (my_node->has_valid_edge()) {
-            success = verify_node(my_node->get_edge_id(), my_node, my_node->get_total_entries(), update_debug_bm);
+            success = verify_node_recursive(my_node->get_edge_id(), my_node, my_node->get_total_entries(), update_debug_bm);
             if (!success) { goto exit_on_error; }
         }
 
@@ -1269,6 +1277,160 @@ class Btree {
         unlock_node(my_node, acq_lock);
         return success;
     }
+    /**
+     * @brief : Iterative btree verification - avoids holding ancestor locks during subtree traversal
+     *
+     * This iterative implementation releases each node's lock and reference immediately after
+     * processing, rather than holding them on the call stack during recursion. Benefits:
+     * - Reduces lock contention: ancestor nodes unlocked while processing descendants
+     * - Enables cache eviction during traversal: ref_count drops to 1 immediately per node
+     * - Lower peak stack depth for deep trees
+     *
+     * Note: This does NOT solve cross-volume cache accumulation during recovery. When multiple
+     * volumes are verified sequentially, cache accumulation occurs across volumes, not within
+     * a single volume's traversal. The solution is force_evict() after each volume completes.
+     *
+     * @param bnodeid : node id
+     * @param parent_node : parent node ptr (unused in iterative - parent info passed via queue)
+     * @param indx : index within parent (unused in iterative)
+     * @param update_debug_bm : true or false
+     *
+     * @return : true if this node including all its children are not corrupted; false if not
+     */
+    bool verify_node_fowarding(bnodeid_t bnodeid, BtreeNodePtr parent_node, uint32_t indx, bool update_debug_bm) {
+        struct NodeToVerify {
+            bnodeid_t node_id;
+            uint32_t parent_index;
+            bool has_parent;
+            K parent_key;
+            K parent_prev_key;
+            uint32_t parent_total_entries;
+            bool validate_with_parent;
+
+            NodeToVerify(bnodeid_t nid, uint32_t idx, bool hp, const K* pkey, const K* pprev,
+                        uint32_t ptotal, bool validate)
+                : node_id(nid), parent_index(idx), has_parent(hp),
+                  parent_total_entries(ptotal), validate_with_parent(validate) {
+                if (pkey) parent_key = *pkey;
+                if (pprev) parent_prev_key = *pprev;
+            }
+        };
+
+        std::queue<NodeToVerify> work_queue;
+        work_queue.push(NodeToVerify(bnodeid, indx, false, nullptr, nullptr, 0, false));
+
+        while (!work_queue.empty()) {
+            NodeToVerify current = work_queue.front();
+            work_queue.pop();
+
+            homeds::thread::locktype acq_lock = homeds::thread::locktype::LOCKTYPE_READ;
+            BtreeNodePtr my_node;
+
+            if (read_and_lock_node(current.node_id, my_node, acq_lock, acq_lock, nullptr) != btree_status_t::success) {
+                LOGERROR("VERIFY_NODE_FAIL: read_and_lock_node failed for node_id={}", current.node_id);
+                return false;
+            }
+
+            if (update_debug_bm &&
+                (btree_store_t::update_debug_bm(m_btree_store.get(), my_node) != btree_status_t::success)) {
+                LOGERROR("bitmap update failed for node {}", my_node->to_string());
+                unlock_node(my_node, acq_lock);
+                return false;
+            }
+
+            K prev_key;
+
+            for (uint32_t i = 0; i < my_node->get_total_entries(); ++i) {
+                K key;
+                my_node->get_nth_key(i, &key, false);
+
+                if (!my_node->is_leaf()) {
+                    BtreeNodeInfo child;
+                    my_node->get(i, &child, false);
+
+                    K* pprev = (i > 0) ? &prev_key : nullptr;
+                    bool validate = (my_node->get_total_entries() != i);
+
+                    work_queue.push(NodeToVerify(child.bnode_id(), i, true, &key, pprev,
+                                                 my_node->get_total_entries(), validate));
+
+                    if (i > 0) {
+                        BT_LOG_ASSERT_CMP(prev_key.compare(&key), <, 0, my_node);
+                        if (prev_key.compare(&key) >= 0) {
+                            LOGERROR("VERIFY_NODE_FAIL: Interior node key ordering violation at index {}: prev_key >= key", i);
+                            unlock_node(my_node, acq_lock);
+                            return false;
+                        }
+                    }
+                }
+
+                if (my_node->is_leaf() && i > 0) {
+                    BT_LOG_ASSERT_CMP(prev_key.compare_start(&key), <, 0, my_node);
+                    if (prev_key.compare_start(&key) >= 0) {
+                        LOGERROR("VERIFY_NODE_FAIL: Leaf node key ordering violation at index {}: prev_key.compare_start(key) >= 0", i);
+                        unlock_node(my_node, acq_lock);
+                        return false;
+                    }
+                }
+                prev_key = key;
+            }
+
+            if (current.has_parent && current.validate_with_parent && my_node->get_total_entries() > 0) {
+                K last_key;
+                my_node->get_nth_key(my_node->get_total_entries() - 1, &last_key, false);
+
+                if (!my_node->is_leaf()) {
+                    if (last_key.compare(&current.parent_key) != 0) {
+                        LOGERROR("Interior node last key {} != parent key {}",
+                                last_key.to_string(), current.parent_key.to_string());
+                        unlock_node(my_node, acq_lock);
+                        return false;
+                    }
+                } else {
+                    if (last_key.compare(&current.parent_key) > 0) {
+                        LOGERROR("Leaf node last key {} > parent key {}",
+                                last_key.to_string(), current.parent_key.to_string());
+                        unlock_node(my_node, acq_lock);
+                        return false;
+                    }
+                    if (current.parent_key.compare_start(&last_key) < 0) {
+                        LOGERROR("Parent key compare_start with last key failed");
+                        unlock_node(my_node, acq_lock);
+                        return false;
+                    }
+                }
+            }
+
+            if (current.has_parent && current.parent_index != 0 && my_node->get_total_entries() > 0) {
+                K first_key;
+                my_node->get_nth_key(0, &first_key, false);
+
+                if (first_key.compare(&current.parent_prev_key) <= 0) {
+                    LOGERROR("First key {} <= parent prev key {}",
+                            first_key.to_string(), current.parent_prev_key.to_string());
+                    unlock_node(my_node, acq_lock);
+                    return false;
+                }
+
+                if (current.parent_prev_key.compare_start(&first_key) >= 0) {
+                    LOGERROR("Parent prev key compare_start with first key failed");
+                    unlock_node(my_node, acq_lock);
+                    return false;
+                }
+            }
+
+            if (my_node->has_valid_edge()) {
+                K last_key;
+                my_node->get_nth_key(my_node->get_total_entries() - 1, &last_key, false);
+                work_queue.push(NodeToVerify(my_node->get_edge_id(), my_node->get_total_entries(),
+                                             true, &last_key, &last_key, my_node->get_total_entries(), false));
+            }
+
+            unlock_node(my_node, acq_lock);
+        }
+
+        return true;
+    }
 
     void to_string(bnodeid_t bnodeid, std::string& buf) {
         BtreeNodePtr node;
diff --git a/src/homeblks/volume/mapping.cpp b/src/homeblks/volume/mapping.cpp
index 438fcb3c8..2df67f0c8 100644
--- a/src/homeblks/volume/mapping.cpp
+++ b/src/homeblks/volume/mapping.cpp
@@ -272,7 +272,7 @@ btree_status_t mapping::put(mapping_op_cntx& cntx, MappingKey& key, MappingValue
 
 uint64_t mapping::get_btree_node_cnt() { return m_bt->get_btree_node_cnt(); }
 void mapping::print_tree() { m_bt->print_tree(); }
-bool mapping::verify_tree(bool update_debug_bm) { return m_bt->verify_tree(update_debug_bm); }
+bool mapping::verify_tree(bool update_debug_bm, bool recursive) { return m_bt->verify_tree(update_debug_bm, recursive); }
 
 sisl::status_response mapping::get_status(const sisl::status_request& request) { return m_bt->get_status(request); }
 
diff --git a/src/homeblks/volume/mapping.hpp b/src/homeblks/volume/mapping.hpp
index b243fa09c..fe022af32 100644
--- a/src/homeblks/volume/mapping.hpp
+++ b/src/homeblks/volume/mapping.hpp
@@ -686,7 +686,7 @@ class mapping : public indx_tbl {
     virtual uint64_t get_btree_node_cnt();
 
     void print_tree();
-    bool verify_tree(bool update_debug_bm);
+    bool verify_tree(bool update_debug_bm, bool recursive = false);
     sisl::sobject_ptr sobject() { return m_sobject; }
     sisl::status_response get_status(const sisl::status_request& request);
 
diff --git a/src/homeblks/volume/volume.cpp b/src/homeblks/volume/volume.cpp
index d7d021c56..21b9c144b 100644
--- a/src/homeblks/volume/volume.cpp
+++ b/src/homeblks/volume/volume.cpp
@@ -921,7 +921,7 @@ volume_child_req_ptr Volume::create_vol_child_req(const BlkId& bid, const volume
 }
 
 void Volume::print_tree() { get_active_indx()->print_tree(); }
-bool Volume::verify_tree(bool update_debug_bm) { return (get_active_indx()->verify_tree(update_debug_bm)); }
+bool Volume::verify_tree(bool update_debug_bm, bool recursive) { return (get_active_indx()->verify_tree(update_debug_bm, recursive)); }
 
 sisl::status_response Volume::get_status(const sisl::status_request& request) {
     sisl::status_response response;
diff --git a/src/homeblks/volume/volume.hpp b/src/homeblks/volume/volume.hpp
index e9477fdce..a07b70f55 100644
--- a/src/homeblks/volume/volume.hpp
+++ b/src/homeblks/volume/volume.hpp
@@ -500,7 +500,7 @@ class Volume : public std::enable_shared_from_this< Volume > {
     void print_tree();
 
     /* verify active indx */
-    bool verify_tree(bool update_debug_bm = false);
+    bool verify_tree(bool update_debug_bm = false, bool recursive = false);
 
     /* get status */
     sisl::status_response get_status(const sisl::status_request& request);

From 70d06eb5dd0eda618ede0837055b4352bbeeb584 Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Fri, 8 May 2026 00:36:52 -0700
Subject: [PATCH 05/10] Add release_cached_tree to safely evict btree node
 buffers from cache

Add release_cached_tree() to evict cached btree nodes when safe:
- Buffer not locked (try_lock succeeds)
- Buffer not dirty (no pending writeback)
- ref_count permits eviction (only cache/wb_cache hold refs)

Implementation:
- btree.hpp: EvictionStats struct + release_cached_tree() + release_cached_nodes_recursive()
- ssd_btree.hpp: free_node_from_cache() with isSyncCall=true to avoid null deref on wb_req->bcp
- mapping.hpp: delegation wrapper
- volume.hpp: delegation wrapper

Safety: Cache::erase (cache_only=true) correctly handles wb_cache refs - buffer removed
from hash_set/eviction list while wb_cache retains ref for checkpoint flush.

Use case: Call after verify_tree() during recovery to release per-volume cache before
processing next volume, preventing cross-volume memory accumulation.
---
 src/engine/homeds/btree/btree.hpp     | 97 +++++++++++++++++++++++++++
 src/engine/homeds/btree/ssd_btree.hpp | 24 +++++++
 src/homeblks/volume/mapping.hpp       |  1 +
 src/homeblks/volume/volume.hpp        |  3 +
 4 files changed, 125 insertions(+)

diff --git a/src/engine/homeds/btree/btree.hpp b/src/engine/homeds/btree/btree.hpp
index 638a0c0ac..67c7e4f4e 100644
--- a/src/engine/homeds/btree/btree.hpp
+++ b/src/engine/homeds/btree/btree.hpp
@@ -751,6 +751,42 @@ class Btree {
         return ret;
     }
 
+    /**
+     * @brief Statistics from release_cached_tree()
+     */
+    struct EvictionStats {
+        uint64_t total_nodes_checked;
+        uint64_t nodes_evicted;
+        uint64_t nodes_with_refs;
+        uint64_t nodes_dirty;
+        uint64_t nodes_locked;
+        uint64_t nodes_not_in_cache;
+
+        EvictionStats() :
+            total_nodes_checked(0),
+            nodes_evicted(0),
+            nodes_with_refs(0),
+            nodes_dirty(0),
+            nodes_locked(0),
+            nodes_not_in_cache(0) {}
+    };
+
+    EvictionStats release_cached_tree() {
+        EvictionStats stats;
+
+        LOGINFO("RELEASE_CACHE: Starting safe cache release for btree: {}", m_btree_cfg.get_name());
+
+        m_btree_lock.read_lock();
+        release_cached_nodes_recursive(m_root_node, stats);
+        m_btree_lock.unlock();
+
+        LOGINFO("RELEASE_CACHE: Completed for btree: {} - total={} evicted={} with_refs={} not_in_cache={}",
+                m_btree_cfg.get_name(), stats.total_nodes_checked, stats.nodes_evicted,
+                stats.nodes_with_refs, stats.nodes_not_in_cache);
+
+        return stats;
+    }
+
     /**
      * @brief : get the status of this btree;
      *
@@ -1432,6 +1468,67 @@ class Btree {
         return true;
     }
 
+    void release_cached_nodes_recursive(bnodeid_t root_bnodeid, EvictionStats& stats) {
+        std::queue<bnodeid_t> work_queue;
+        work_queue.push(root_bnodeid);
+
+        while (!work_queue.empty()) {
+            bnodeid_t current_id = work_queue.front();
+            work_queue.pop();
+
+            stats.total_nodes_checked++;
+
+            BtreeNodePtr my_node;
+            homeds::thread::locktype acq_lock = homeds::thread::locktype::LOCKTYPE_READ;
+
+            if (read_and_lock_node(current_id, my_node, acq_lock, acq_lock, nullptr) != btree_status_t::success) {
+                stats.nodes_not_in_cache++;
+                continue;
+            }
+
+            std::vector<bnodeid_t> child_ids;
+            if (!my_node->is_leaf()) {
+                for (uint32_t i = 0; i < my_node->get_total_entries(); ++i) {
+                    BtreeNodeInfo child;
+                    my_node->get(i, &child, false);
+                    child_ids.push_back(child.bnode_id());
+                }
+                if (my_node->has_valid_edge()) {
+                    child_ids.push_back(my_node->get_edge_id());
+                }
+            }
+
+            for (const auto& child_id : child_ids) {
+                work_queue.push(child_id);
+            }
+
+            unlock_node(my_node, acq_lock);
+            my_node.reset();
+
+            BtreeNodePtr check_node;
+            if (read_and_lock_node(current_id, check_node, acq_lock, acq_lock, nullptr) == btree_status_t::success) {
+                if constexpr (BtreeStoreType == btree_store_type::SSD_BTREE) {
+                    unlock_node(check_node, acq_lock);
+                    check_node.reset();
+
+                    const uint32_t node_size = m_btree_store->get_node_size();
+                    bool evicted = btree_store_t::free_node_from_cache(current_id, node_size);
+
+                    if (evicted) {
+                        stats.nodes_evicted++;
+                    } else {
+                        stats.nodes_with_refs++;
+                    }
+                } else {
+                    stats.nodes_with_refs++;
+                    unlock_node(check_node, acq_lock);
+                }
+            } else {
+                stats.nodes_evicted++;
+            }
+        }
+    }
+
     void to_string(bnodeid_t bnodeid, std::string& buf) {
         BtreeNodePtr node;
 
diff --git a/src/engine/homeds/btree/ssd_btree.hpp b/src/engine/homeds/btree/ssd_btree.hpp
index 086e1e830..522570453 100644
--- a/src/engine/homeds/btree/ssd_btree.hpp
+++ b/src/engine/homeds/btree/ssd_btree.hpp
@@ -458,6 +458,30 @@ class SSDBtreeStore {
         store->get_wb_cache()->free_blk(bn->get_node_id(), free_blkid_list, store->get_node_size());
     }
 
+    static bool free_node_from_cache(bnodeid_t node_id, uint32_t node_size) {
+        homestore::BlkId bid(node_id);
+
+        auto req = writeback_req_t::make_request();
+        req->isSyncCall = true;
+        auto buf = m_blkstore->read(bid, 0, node_size, req, true);
+
+        if (!buf) { return true; }
+
+        if (!buf->try_lock()) {
+            buf.reset();
+            return false;
+        }
+        buf->unlock();
+        buf.reset();
+
+        m_blkstore->free_blk(bid, boost::none, boost::none, true);
+
+        auto verify_req = writeback_req_t::make_request();
+        verify_req->isSyncCall = true;
+        auto verify_buf = m_blkstore->read(bid, 0, node_size, verify_req, true);
+        return (verify_buf == nullptr);
+    }
+
     static void ref_node(SSDBtreeNode* const bn) {
         // ref base class
         homestore::CacheBuffer< homestore::BlkId >::ref(
diff --git a/src/homeblks/volume/mapping.hpp b/src/homeblks/volume/mapping.hpp
index fe022af32..8659a0582 100644
--- a/src/homeblks/volume/mapping.hpp
+++ b/src/homeblks/volume/mapping.hpp
@@ -687,6 +687,7 @@ class mapping : public indx_tbl {
 
     void print_tree();
     bool verify_tree(bool update_debug_bm, bool recursive = false);
+    auto release_cached_tree() { return m_bt->release_cached_tree(); }
     sisl::sobject_ptr sobject() { return m_sobject; }
     sisl::status_response get_status(const sisl::status_request& request);
 
diff --git a/src/homeblks/volume/volume.hpp b/src/homeblks/volume/volume.hpp
index a07b70f55..7850f48f2 100644
--- a/src/homeblks/volume/volume.hpp
+++ b/src/homeblks/volume/volume.hpp
@@ -502,6 +502,9 @@ class Volume : public std::enable_shared_from_this< Volume > {
     /* verify active indx */
     bool verify_tree(bool update_debug_bm = false, bool recursive = false);
 
+    /* release cached tree nodes */
+    auto release_cached_tree() { return get_active_indx()->release_cached_tree(); }
+
     /* get status */
     sisl::status_response get_status(const sisl::status_request& request);
 

From f88e9514363b6cbbb7eca88e6d7698747234f0aa Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Fri, 8 May 2026 00:44:07 -0700
Subject: [PATCH 06/10] Call release_cached_tree after each volume recovery to
 prevent accumulation

In vol_recovery_start_phase2(), call release_cached_tree() after recovery_start_phase2()
finishes for each volume. This proactively evicts clean cached btree nodes, providing:

1. Limits peak memory: max(single volume) instead of sum(all volumes)
   Without this fix, cache accumulates across volumes during sequential recovery.

2. Frees cache space for dirty buffers: Clean nodes from verify_tree() consume cache
   quota but provide zero value after recovery. Evicting them makes room for dirty
   buffers that need cache space for writeback/checkpoint.

3. Defensive against future bugs: Reduces OOM risk from any dirty buffer accumulation
   by not wasting cache on stale clean buffers.

Critical ordering per volume:
1. verify_tree() - loads nodes into cache for verification
2. recovery_start_phase2() - io_replay needs nodes in cache
3. release_cached_tree() - safe to evict after io_replay completes
---
 src/homeblks/home_blks.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/homeblks/home_blks.cpp b/src/homeblks/home_blks.cpp
index e969b50fd..cf37278dd 100644
--- a/src/homeblks/home_blks.cpp
+++ b/src/homeblks/home_blks.cpp
@@ -1116,7 +1116,18 @@ void HomeBlks::vol_recovery_start_phase2() {
     auto phase2_start = Clock::now();
     for (auto it = m_volume_map.cbegin(); it != m_volume_map.cend(); ++it) {
         HS_REL_ASSERT((it->second->verify_tree() == true), "true");
+
         it->second->recovery_start_phase2();
+
+        LOGINFO("RELEASE_CACHE: Starting cache release after recovery for volume: {}", it->second->get_name());
+        auto eviction_stats = it->second->release_cached_tree();
+        LOGINFO("RELEASE_CACHE: Eviction stats for volume: {} - "
+                "total_checked={} evicted={} with_refs={} not_in_cache={}",
+                it->second->get_name(),
+                eviction_stats.total_nodes_checked,
+                eviction_stats.nodes_evicted,
+                eviction_stats.nodes_with_refs,
+                eviction_stats.nodes_not_in_cache);
     }
 
     m_recovery_stats->m_phase2_ms = get_elapsed_time_ms(phase2_start);

From 780d98f529893ad9da4e55a7ee02f4defeb94fdd Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Fri, 8 May 2026 00:54:48 -0700
Subject: [PATCH 07/10] Add config flag to enable/disable cache release after
 recovery

Add release_cache_after_recovery boolean flag to GeneralConfig in homeblks_config.fbs
with default value true. This allows runtime control of cache release behavior during
volume recovery phase 2.

When enabled (default), cached btree nodes are safely evicted after each volume's
recovery to limit peak memory usage and free cache space for dirty buffers.

The flag is marked as hotswap, allowing dynamic configuration updates without restart.
---
 src/homeblks/home_blks.cpp       | 20 +++++++++++---------
 src/homeblks/homeblks_config.fbs |  7 ++++++-
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/homeblks/home_blks.cpp b/src/homeblks/home_blks.cpp
index cf37278dd..89cf4f63a 100644
--- a/src/homeblks/home_blks.cpp
+++ b/src/homeblks/home_blks.cpp
@@ -1119,15 +1119,17 @@ void HomeBlks::vol_recovery_start_phase2() {
 
         it->second->recovery_start_phase2();
 
-        LOGINFO("RELEASE_CACHE: Starting cache release after recovery for volume: {}", it->second->get_name());
-        auto eviction_stats = it->second->release_cached_tree();
-        LOGINFO("RELEASE_CACHE: Eviction stats for volume: {} - "
-                "total_checked={} evicted={} with_refs={} not_in_cache={}",
-                it->second->get_name(),
-                eviction_stats.total_nodes_checked,
-                eviction_stats.nodes_evicted,
-                eviction_stats.nodes_with_refs,
-                eviction_stats.nodes_not_in_cache);
+        if (HB_DYNAMIC_CONFIG(general_config->release_cache_after_recovery)) {
+            LOGINFO("RELEASE_CACHE: Starting cache release after recovery for volume: {}", it->second->get_name());
+            auto eviction_stats = it->second->release_cached_tree();
+            LOGINFO("RELEASE_CACHE: Eviction stats for volume: {} - "
+                    "total_checked={} evicted={} with_refs={} not_in_cache={}",
+                    it->second->get_name(),
+                    eviction_stats.total_nodes_checked,
+                    eviction_stats.nodes_evicted,
+                    eviction_stats.nodes_with_refs,
+                    eviction_stats.nodes_not_in_cache);
+        }
     }
 
     m_recovery_stats->m_phase2_ms = get_elapsed_time_ms(phase2_start);
diff --git a/src/homeblks/homeblks_config.fbs b/src/homeblks/homeblks_config.fbs
index 42566a9c4..0d6cc9d72 100644
--- a/src/homeblks/homeblks_config.fbs
+++ b/src/homeblks/homeblks_config.fbs
@@ -28,9 +28,14 @@ table GeneralConfig {
 
     // Frequency with which we need to check the success of shutdown
     shutdown_status_check_freq_ms: uint64 = 2000;
-    // Consistency check on booting 
+    // Consistency check on booting
     boot_consistency_check: bool = false;
 
+    // Enable cache release after volume recovery to limit peak memory usage.
+    // When enabled, cached btree nodes are safely evicted after each volume's
+    // recovery phase 2, freeing cache space for dirty buffers.
+    release_cache_after_recovery: bool = true (hotswap);
+
     // These fields should only be changed by agent through workflow
     boot_restricted_mode: bool = false;
     boot_safe_mode: bool = false;

From 9e6d37c305873ff7b2c5a183ae9c3683faa6081e Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Fri, 8 May 2026 00:57:04 -0700
Subject: [PATCH 08/10] Add metric to track cache release overhead during
 recovery

Add recovery_cache_release_latency gauge to HomeBlksMetrics and m_cache_release_ms
field to HomeBlksRecoveryStats to track time spent releasing cached btree nodes
during volume recovery phase 2.

The metric accumulates time across all volumes and logs per-volume cache release
duration. This enables monitoring the performance overhead of cache eviction and
helps identify if the cache release operation becomes a bottleneck during recovery.
---
 src/homeblks/home_blks.cpp | 13 +++++++++++--
 src/homeblks/home_blks.hpp | 18 ++++++++++--------
 2 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/src/homeblks/home_blks.cpp b/src/homeblks/home_blks.cpp
index 89cf4f63a..1120a385b 100644
--- a/src/homeblks/home_blks.cpp
+++ b/src/homeblks/home_blks.cpp
@@ -526,6 +526,7 @@ void HomeBlks::init_done() {
     GAUGE_UPDATE(*m_metrics, recovery_phase1_latency, m_recovery_stats->m_phase1_ms);
     GAUGE_UPDATE(*m_metrics, recovery_phase2_latency, m_recovery_stats->m_phase2_ms);
     GAUGE_UPDATE(*m_metrics, recovery_log_store_latency, m_recovery_stats->m_log_store_ms);
+    GAUGE_UPDATE(*m_metrics, recovery_cache_release_latency, m_recovery_stats->m_cache_release_ms);
     GAUGE_UPDATE(*m_metrics, recovery_total_latency, m_recovery_stats->m_total_ms);
 
     // start the io watchdog;
@@ -1114,24 +1115,32 @@ void HomeBlks::vol_recovery_start_phase1() {
 
 void HomeBlks::vol_recovery_start_phase2() {
     auto phase2_start = Clock::now();
+    auto cache_release_start = Clock::now();
+    uint64_t total_cache_release_time_ms = 0;
+
     for (auto it = m_volume_map.cbegin(); it != m_volume_map.cend(); ++it) {
         HS_REL_ASSERT((it->second->verify_tree() == true), "true");
 
         it->second->recovery_start_phase2();
 
         if (HB_DYNAMIC_CONFIG(general_config->release_cache_after_recovery)) {
+            cache_release_start = Clock::now();
             LOGINFO("RELEASE_CACHE: Starting cache release after recovery for volume: {}", it->second->get_name());
             auto eviction_stats = it->second->release_cached_tree();
+            auto cache_release_time_ms = get_elapsed_time_ms(cache_release_start);
+            total_cache_release_time_ms += cache_release_time_ms;
             LOGINFO("RELEASE_CACHE: Eviction stats for volume: {} - "
-                    "total_checked={} evicted={} with_refs={} not_in_cache={}",
+                    "total_checked={} evicted={} with_refs={} not_in_cache={} time_ms={}",
                     it->second->get_name(),
                     eviction_stats.total_nodes_checked,
                     eviction_stats.nodes_evicted,
                     eviction_stats.nodes_with_refs,
-                    eviction_stats.nodes_not_in_cache);
+                    eviction_stats.nodes_not_in_cache,
+                    cache_release_time_ms);
         }
     }
 
+    m_recovery_stats->m_cache_release_ms = total_cache_release_time_ms;
     m_recovery_stats->m_phase2_ms = get_elapsed_time_ms(phase2_start);
 }
 
diff --git a/src/homeblks/home_blks.hpp b/src/homeblks/home_blks.hpp
index 84eb613ed..d23692504 100644
--- a/src/homeblks/home_blks.hpp
+++ b/src/homeblks/home_blks.hpp
@@ -111,6 +111,7 @@ class HomeBlksMetrics : public sisl::MetricsGroupWrapper {
         REGISTER_GAUGE(recovery_phase2_latency, "recovery phase2 latency");
         REGISTER_GAUGE(recovery_log_store_latency, "recovery logstore latency");
         REGISTER_GAUGE(recovery_total_latency, "recovery total latency");
+        REGISTER_GAUGE(recovery_cache_release_latency, "recovery cache release latency");
         REGISTER_GAUGE(unclean_shutdown, "unclean shutdown");
         register_me_to_farm();
     }
@@ -127,12 +128,13 @@ typedef WriteBackCacheBuffer< MappingKey, MappingValue, btree_node_type::VAR_VAL
     BLKSTORE_BUFFER_TYPE;
 
 struct HomeBlksRecoveryStats {
-    Clock::time_point m_start;  // recovery start time
-    uint64_t m_phase0_ms{0};    // time spent in phase0: from init to receipt of meta_blk_recovery_comp_cb;
-    uint64_t m_phase1_ms{0};    // time spent in phase1: volume Phase 1
-    uint64_t m_phase2_ms{0};    // time spent in phase2: volume Phase 2
-    uint64_t m_log_store_ms{0}; // time spent in logstore recovery
-    uint64_t m_total_ms{0};     // total: from metablk notify homeblks of comp_cb to init_done;
+    Clock::time_point m_start;        // recovery start time
+    uint64_t m_phase0_ms{0};          // time spent in phase0: from init to receipt of meta_blk_recovery_comp_cb;
+    uint64_t m_phase1_ms{0};          // time spent in phase1: volume Phase 1
+    uint64_t m_phase2_ms{0};          // time spent in phase2: volume Phase 2
+    uint64_t m_log_store_ms{0};       // time spent in logstore recovery
+    uint64_t m_cache_release_ms{0};   // time spent releasing cached nodes after recovery
+    uint64_t m_total_ms{0};           // total: from metablk notify homeblks of comp_cb to init_done;
 
     void phase0_done() { m_phase0_ms = get_elapsed_time_ms(m_start); }
 
@@ -145,8 +147,8 @@ struct HomeBlksRecoveryStats {
 
     std::string to_string() {
         return fmt::format("Recovery Total (ms): {}, Volume Phase-0 (ms): {},  Volume Phase-1 (ms): {}, Log Store "
-                           "Recovery (ms): {}, Volume Phase-2 (ms): {}",
-                           m_total_ms, m_phase0_ms, m_phase1_ms, m_log_store_ms, m_phase2_ms);
+                           "Recovery (ms): {}, Volume Phase-2 (ms): {}, Cache Release (ms): {}",
+                           m_total_ms, m_phase0_ms, m_phase1_ms, m_log_store_ms, m_phase2_ms, m_cache_release_ms);
     }
 };
 

From 4036f81b52bf8ae52fe4a1c97bda65eee07c952a Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Fri, 8 May 2026 01:04:08 -0700
Subject: [PATCH 09/10] Apply clang-format to all source files

Run ./apply-clang-format.sh to format all C++ source files according to
src/.clang-format style configuration. This ensures consistent code style
across the codebase.
---
 src/api/vol_interface.hpp                     |   2 +-
 src/engine/blkalloc/blk_allocator.h           |   2 +-
 src/engine/blkalloc/blk_cache_queue.cpp       |   7 +-
 src/engine/blkalloc/test_blk_cache_queue.cpp  |   4 +-
 src/engine/blkalloc/test_blkalloc.cpp         |   8 +-
 src/engine/blkalloc/varsize_blk_allocator.h   |   1 +
 src/engine/blkstore/blkbuffer.hpp             |   2 +-
 src/engine/blkstore/blkstore.hpp              |   6 +-
 src/engine/cache/cache.h                      |   8 +-
 src/engine/cache/test_cache.cpp               |   4 +-
 .../cache/unused/evictable_mem_alloc.cpp      |   7 +-
 src/engine/cache/unused/evictable_mem_alloc.h |   2 +-
 src/engine/cache/unused/eviction.cpp          |   6 +-
 src/engine/common/homestore_utils.cpp         |  16 +-
 src/engine/common/homestore_utils.hpp         |   5 +-
 src/engine/device/device.h                    |   6 +-
 src/engine/homeds/btree/btree.hpp             |  81 +--
 src/engine/homeds/btree/btree_internal.h      |   6 +-
 src/engine/homeds/btree/btree_node.h          |   2 +-
 src/engine/homeds/btree/mem_btree.hpp         |   2 +-
 src/engine/homeds/btree/prefix_node.hpp       |   4 +-
 src/engine/homeds/btree/writeBack_cache.hpp   |   4 +-
 src/engine/homeds/loadgen/loadgen.hpp         |   2 +-
 src/engine/homeds/memory/chunk_allocator.hpp  |   2 +-
 .../memory/memory.old/chunk_allocator2.hpp    |  20 +-
 .../memory/memory.old/mem_allocator.hpp       |  16 +-
 .../homeds/memory/memory.old/smart_ptr.hpp    |  12 +-
 src/engine/homeds/memory/mempiece.hpp         |   6 +-
 .../homeds/tests/loadgen_tests/test_load.cpp  |  22 +-
 .../valuespecs/cache_value_spec.hpp           |   2 +-
 src/engine/homeds/tests/test_btree_crud.cpp   |   2 +-
 src/engine/homeds/utility/stats.hpp           |   2 +-
 src/engine/homeds/utility/useful_defs.hpp     |   6 +-
 src/engine/homestore.hpp                      |  10 +-
 src/engine/index/checkpoint.hpp               |   2 +-
 src/engine/index/indx_mgr.hpp                 |   5 +-
 src/engine/meta/test_meta_blk_mgr.cpp         |  19 +-
 src/homeblks/home_blks.cpp                    |  16 +-
 src/homeblks/home_blks.hpp                    |  16 +-
 src/homeblks/homeblks_http_server.cpp         |   9 +-
 src/homeblks/volume/mapping.cpp               |   4 +-
 src/homeblks/volume/mapping.hpp               |   2 +-
 src/homeblks/volume/snapshot.hpp              |   4 +-
 src/homeblks/volume/tests/vol_gtest.cpp       |   4 +-
 src/homeblks/volume/tests/vol_merge_test.cpp  |   2 +-
 src/homeblks/volume/volume.cpp                |   4 +-
 src/homeblks/volume/volume.hpp                |  13 +-
 src/homelogstore/log_store_family.cpp         |   5 +-
 src/homelogstore/log_store_family.hpp         |   2 -
 src/homelogstore/log_store_mgr.cpp            |   9 +-
 src/homelogstore/tests/test_log_store.cpp     |   4 +-
 src/replication/repl_log_store/lib/crc32.cc   | 529 ++++++++----------
 .../repl_log_store/lib/endian_encode.h        |  11 +-
 src/replication/repl_log_store/lib/hex_dump.h |   7 +-
 src/replication/repl_log_store/lib/stat.cc    |  96 ++--
 src/test_common/homestore_test_common.hpp     |   2 +-
 56 files changed, 479 insertions(+), 573 deletions(-)

diff --git a/src/api/vol_interface.hpp b/src/api/vol_interface.hpp
index 53627911b..2ccec9541 100644
--- a/src/api/vol_interface.hpp
+++ b/src/api/vol_interface.hpp
@@ -316,7 +316,7 @@ class VolInterface {
 
     virtual const char* get_name(const VolumePtr& vol) = 0;
     virtual uint64_t get_size(const VolumePtr& vol) = 0;
-    virtual std::map<boost::uuids::uuid, uint64_t> get_used_size(const VolumePtr& vol) = 0;
+    virtual std::map< boost::uuids::uuid, uint64_t > get_used_size(const VolumePtr& vol) = 0;
     virtual uint64_t get_page_size(const VolumePtr& vol) = 0;
     virtual boost::uuids::uuid get_uuid(std::shared_ptr< Volume > vol) = 0;
     virtual sisl::blob at_offset(const boost::intrusive_ptr< BlkBuffer >& buf, uint32_t offset) = 0;
diff --git a/src/engine/blkalloc/blk_allocator.h b/src/engine/blkalloc/blk_allocator.h
index 4d620a568..042bc7693 100644
--- a/src/engine/blkalloc/blk_allocator.h
+++ b/src/engine/blkalloc/blk_allocator.h
@@ -135,7 +135,7 @@ struct blk_alloc_hints {
             is_contiguous{false},
             multiplier{1},
             max_blks_per_entry{BlkId::max_blks_in_op()},
-            stream_info{(uintptr_t) nullptr} {}
+            stream_info{(uintptr_t)nullptr} {}
 
     blk_temp_t desired_temp;       // Temperature hint for the device
     uint32_t dev_id_hint;          // which physical device to pick (hint if any) -1 for don't care
diff --git a/src/engine/blkalloc/blk_cache_queue.cpp b/src/engine/blkalloc/blk_cache_queue.cpp
index 347fad8e5..a2644acde 100644
--- a/src/engine/blkalloc/blk_cache_queue.cpp
+++ b/src/engine/blkalloc/blk_cache_queue.cpp
@@ -314,8 +314,8 @@ SlabCacheQueue::SlabCacheQueue(const blk_count_t slab_size, const std::vector< b
 }
 
 std::optional< blk_temp_t > SlabCacheQueue::push(const blk_cache_entry& entry, const bool only_this_level) {
-    const blk_temp_t start_level{
-        static_cast< blk_temp_t >((entry.get_temperature() >= m_level_queues.size()) ? m_level_queues.size() - 1 : entry.get_temperature())};
+    const blk_temp_t start_level{static_cast< blk_temp_t >(
+        (entry.get_temperature() >= m_level_queues.size()) ? m_level_queues.size() - 1 : entry.get_temperature())};
     blk_temp_t level{start_level};
     bool pushed{m_level_queues[start_level]->write(entry)};
 
@@ -378,7 +378,8 @@ void SlabCacheQueue::close_session(const uint64_t session_id) {
     m_refill_session.compare_exchange_strong(expected_session_id, 0, std::memory_order_acq_rel);
 }
 
-SlabMetrics::SlabMetrics(const blk_count_t slab_size, SlabCacheQueue* const slab_queue, VarsizeBlkAllocMetrics* const parent) :
+SlabMetrics::SlabMetrics(const blk_count_t slab_size, SlabCacheQueue* const slab_queue,
+                         VarsizeBlkAllocMetrics* const parent) :
         sisl::MetricsGroup{"SlabMetrics", fmt::format("{}_slab_{:03d}", parent->instance_name(), slab_size)},
         m_slab_queue{slab_queue} {
     REGISTER_COUNTER(num_slab_alloc, "Number of alloc attempts in this slab");
diff --git a/src/engine/blkalloc/test_blk_cache_queue.cpp b/src/engine/blkalloc/test_blk_cache_queue.cpp
index 64565d77a..c64b81546 100644
--- a/src/engine/blkalloc/test_blk_cache_queue.cpp
+++ b/src/engine/blkalloc/test_blk_cache_queue.cpp
@@ -52,8 +52,8 @@ struct BlkCacheQueueTest : public ::testing::Test {
     virtual ~BlkCacheQueueTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
-    virtual void TearDown() override{};
+    virtual void SetUp() override {};
+    virtual void TearDown() override {};
 
     void SetUp(const uint32_t nslabs, const uint32_t count_per_slab) {
         m_nslabs = nslabs;
diff --git a/src/engine/blkalloc/test_blkalloc.cpp b/src/engine/blkalloc/test_blkalloc.cpp
index e965ebd2d..86159e5df 100644
--- a/src/engine/blkalloc/test_blkalloc.cpp
+++ b/src/engine/blkalloc/test_blkalloc.cpp
@@ -380,8 +380,8 @@ struct FixedBlkAllocatorTest : public ::testing::Test, BlkAllocatorTest {
     FixedBlkAllocatorTest& operator=(FixedBlkAllocatorTest&&) noexcept = delete;
     virtual ~FixedBlkAllocatorTest() override = default;
 
-    virtual void SetUp() override{};
-    virtual void TearDown() override{};
+    virtual void SetUp() override {};
+    virtual void TearDown() override {};
 
     [[nodiscard]] bool alloc_blk(const BlkAllocStatus exp_status, BlkId& bid, const bool track_block_group) {
         const auto ret{m_allocator->alloc(bid)};
@@ -425,8 +425,8 @@ struct VarsizeBlkAllocatorTest : public ::testing::Test, BlkAllocatorTest {
     VarsizeBlkAllocatorTest& operator=(VarsizeBlkAllocatorTest&&) noexcept = delete;
     virtual ~VarsizeBlkAllocatorTest() override = default;
 
-    virtual void SetUp() override{};
-    virtual void TearDown() override{};
+    virtual void SetUp() override {};
+    virtual void TearDown() override {};
 
     void create_allocator(const bool use_slabs = true) {
         VarsizeBlkAllocConfig cfg{4096, 4096, 4096u, static_cast< uint64_t >(m_total_count) * 4096, "", false};
diff --git a/src/engine/blkalloc/varsize_blk_allocator.h b/src/engine/blkalloc/varsize_blk_allocator.h
index 2ff1cf289..0fc04bf70 100644
--- a/src/engine/blkalloc/varsize_blk_allocator.h
+++ b/src/engine/blkalloc/varsize_blk_allocator.h
@@ -42,6 +42,7 @@ typedef blk_num_t seg_num_t;
 
 class VarsizeBlkAllocConfig : public BlkAllocConfig {
     friend class VarsizeBlkAllocator;
+
 private:
     uint32_t m_phys_page_size;
     seg_num_t m_nsegments;
diff --git a/src/engine/blkstore/blkbuffer.hpp b/src/engine/blkstore/blkbuffer.hpp
index 65b7ade56..f97e9095c 100644
--- a/src/engine/blkstore/blkbuffer.hpp
+++ b/src/engine/blkstore/blkbuffer.hpp
@@ -38,7 +38,7 @@ class BlkBuffer : public CacheBuffer< BlkId > {
     BlkBuffer& operator=(BlkBuffer&&) noexcept = delete;
     virtual ~BlkBuffer() override = default;
 
-    virtual void init() override{};
+    virtual void init() override {};
 
     template < typename... Args >
     static BlkBuffer* make_object(Args&&... args) {
diff --git a/src/engine/blkstore/blkstore.hpp b/src/engine/blkstore/blkstore.hpp
index b9a658360..3b28757be 100644
--- a/src/engine/blkstore/blkstore.hpp
+++ b/src/engine/blkstore/blkstore.hpp
@@ -168,8 +168,10 @@ class BlkStoreMetrics : public sisl::MetricsGroupWrapper {
                            HistogramBucketsType(LinearUpto64Buckets))
         REGISTER_HISTOGRAM(blkstore_cache_read_latency, "BlkStore cache read latency");
         REGISTER_HISTOGRAM(blkstore_cache_write_latency, "BlkStore cache write latency");
-        REGISTER_HISTOGRAM(blkstore_drive_write_latency, "BlkStore drive write latency", HistogramBucketsType(OpLatecyBuckets));
-        REGISTER_HISTOGRAM(blkstore_drive_read_latency, "BlkStore drive read latency", HistogramBucketsType(OpLatecyBuckets));
+        REGISTER_HISTOGRAM(blkstore_drive_write_latency, "BlkStore drive write latency",
+                           HistogramBucketsType(OpLatecyBuckets));
+        REGISTER_HISTOGRAM(blkstore_drive_read_latency, "BlkStore drive read latency",
+                           HistogramBucketsType(OpLatecyBuckets));
 
         register_me_to_farm();
     }
diff --git a/src/engine/cache/cache.h b/src/engine/cache/cache.h
index 058dbedef..fa44fac24 100644
--- a/src/engine/cache/cache.h
+++ b/src/engine/cache/cache.h
@@ -67,7 +67,7 @@ class CacheRecord : public homeds::HashNode, sisl::ObjLifeCounter< CacheRecord >
 
 /* Number of entries we ideally want to have per hash bucket. This number if small, will reduce contention and
  * speed of read/writes, but at the cost of increased memory */
-//#define ENTRIES_PER_BUCKET 2
+// #define ENTRIES_PER_BUCKET 2
 
 /* Number of eviction partitions. More the partitions better the parallelization of requests, but lesser the
  * effectiveness of cache, since it could get evicted sooner than expected, if distribution of key hashing is not
@@ -425,11 +425,13 @@ class CacheBuffer : public CacheRecord {
         // Actual memory cost per cached entry includes overhead beyond the raw data buffer:
         //   sizeof(CacheBufferType): CacheBuffer base class + derived class (e.g., BtreeNode) members
         //   sizeof(homeds::MemVector): MemVector object holding buffer metadata (80 bytes measured via GDB)
-        //   sizeof(homeds::MemPiece): MemPiece[1] array for contiguous buffer tracking (32 bytes, tcmalloc rounds 18→32)
+        //   sizeof(homeds::MemPiece): MemPiece[1] array for contiguous buffer tracking (32 bytes, tcmalloc rounds
+        //   18→32)
         // m_cache_size tracks only the raw data buffer (e.g., 512B or 4096B for btree nodes)
         // For btree nodes, empirical validation via GDB: 832B total = 512B data + 320B overhead
         // This formula ensures cache_size metric and eviction threshold reflect true RSS cost
-        static constexpr uint32_t k_overhead{sizeof(CacheBufferType) + sizeof(homeds::MemVector) + sizeof(homeds::MemPiece)};
+        static constexpr uint32_t k_overhead{sizeof(CacheBufferType) + sizeof(homeds::MemVector) +
+                                             sizeof(homeds::MemPiece)};
         return cbuf->get_cache_size() + k_overhead;
     }
 };
diff --git a/src/engine/cache/test_cache.cpp b/src/engine/cache/test_cache.cpp
index cdbdb162a..dd16387fb 100644
--- a/src/engine/cache/test_cache.cpp
+++ b/src/engine/cache/test_cache.cpp
@@ -89,9 +89,9 @@ struct CacheTest : public ::testing::Test {
 
     virtual ~CacheTest() override { m_cache.reset(); }
 
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
 
-    virtual void TearDown() override{};
+    virtual void TearDown() override {};
 
     [[nodiscard]] bool insert_one(const uint64_t id, const uint32_t size) {
         boost::intrusive_ptr< homestore::CacheBuffer< blk_id > > cbuf;
diff --git a/src/engine/cache/unused/evictable_mem_alloc.cpp b/src/engine/cache/unused/evictable_mem_alloc.cpp
index 97d285522..a25b523f8 100644
--- a/src/engine/cache/unused/evictable_mem_alloc.cpp
+++ b/src/engine/cache/unused/evictable_mem_alloc.cpp
@@ -22,8 +22,7 @@ namespace omstore {
 template < ssize_t MinAllocSize >
 EvictableMemAllocator::EvictableMemAllocator(uint64_t mem_size, CanEvictCallback& can_evict_cb,
                                              AllocEvictCallback& alloc_cb) :
-        m_evict_cb(can_evict_cb),
-        m_alloc_cb(alloc_cb) {
+        m_evict_cb(can_evict_cb), m_alloc_cb(alloc_cb) {
 
     // First add all entries as max alloc cbs
     m_buf = std::make_unique< uint8_t[] >(mem_size);
@@ -61,9 +60,7 @@ bool EvictableMemAllocator::alloc(uint32_t size, uint32_t max_pieces, EvictRecor
         }
     }
 
-    if (!found) {
-        throw std::bad_alloc();
-    }
+    if (!found) { throw std::bad_alloc(); }
     return found;
 }
 
diff --git a/src/engine/cache/unused/evictable_mem_alloc.h b/src/engine/cache/unused/evictable_mem_alloc.h
index c9c74ff0c..725b12be7 100644
--- a/src/engine/cache/unused/evictable_mem_alloc.h
+++ b/src/engine/cache/unused/evictable_mem_alloc.h
@@ -26,7 +26,7 @@
 
 namespace omstore {
 
-#define round_off(val, rnd) ((((val)-1) / (rnd)) + 1)
+#define round_off(val, rnd) ((((val) - 1) / (rnd)) + 1)
 
 template < int SizeMultiplier >
 struct MemPiece {
diff --git a/src/engine/cache/unused/eviction.cpp b/src/engine/cache/unused/eviction.cpp
index 3d671be81..9bc479b33 100644
--- a/src/engine/cache/unused/eviction.cpp
+++ b/src/engine/cache/unused/eviction.cpp
@@ -26,11 +26,7 @@ namespace homestore {
 template < typename EvictionPolicy >
 Evictor< EvictionPolicy >::Evictor(uint64_t max_size, Evictor< EvictionPolicy >::CanEvictCallback cb,
                                    Evictor< EvictionPolicy >::GetSizeCallback gs_cb) :
-        m_evict_policy(cb, gs_cb),
-        m_can_evict_cb(cb),
-        m_get_size_cb(gs_cb),
-        m_cur_size(0),
-        m_max_size(max_size) {}
+        m_evict_policy(cb, gs_cb), m_can_evict_cb(cb), m_get_size_cb(gs_cb), m_cur_size(0), m_max_size(max_size) {}
 
 template < typename EvictionPolicy >
 EvictRecord* Evictor< EvictionPolicy >::add_record(EvictRecord& r) {
diff --git a/src/engine/common/homestore_utils.cpp b/src/engine/common/homestore_utils.cpp
index fa60cbb3a..29f56a08c 100644
--- a/src/engine/common/homestore_utils.cpp
+++ b/src/engine/common/homestore_utils.cpp
@@ -90,15 +90,12 @@ std::string hs_utils::encodeBase64(const uint8_t* first, std::size_t size) {
     return encoded.append(bytes_to_pad, '=');
 }
 
-std::string hs_utils::encodeBase64(const sisl::byte_view& b){
-    return encodeBase64(b.bytes(), b.size());
-}
+std::string hs_utils::encodeBase64(const sisl::byte_view& b) { return encodeBase64(b.bytes(), b.size()); }
 
-template <typename T>
-void hs_utils::decodeBase64(const std::string &encoded_data, T out)
-{
+template < typename T >
+void hs_utils::decodeBase64(const std::string& encoded_data, T out) {
     using BinaryFromBase64 = boost::archive::iterators::transform_width<
-        boost::archive::iterators::binary_from_base64<std::string::const_iterator>,
+        boost::archive::iterators::binary_from_base64< std::string::const_iterator >,
         8, // get a view of 8 bit
         6  // from a sequence of 6 bit
         >;
@@ -107,14 +104,13 @@ void hs_utils::decodeBase64(const std::string &encoded_data, T out)
     std::replace(begin(unpadded_data), end(unpadded_data), '=', 'A'); // A_64 == \0
 
     std::string decoded_data{BinaryFromBase64{begin(unpadded_data)},
-                        BinaryFromBase64{begin(unpadded_data) + unpadded_data.length()}};
+                             BinaryFromBase64{begin(unpadded_data) + unpadded_data.length()}};
 
     decoded_data.erase(end(decoded_data) - bytes_to_pad, end(decoded_data));
     std::copy(begin(decoded_data), end(decoded_data), out);
 }
 
-std::string hs_utils::decodeBase64(const std::string &encoded_data)
-{
+std::string hs_utils::decodeBase64(const std::string& encoded_data) {
     std::string rv;
     decodeBase64(encoded_data, std::back_inserter(rv));
     return rv;
diff --git a/src/engine/common/homestore_utils.hpp b/src/engine/common/homestore_utils.hpp
index b1313df96..967fbea9b 100644
--- a/src/engine/common/homestore_utils.hpp
+++ b/src/engine/common/homestore_utils.hpp
@@ -40,8 +40,9 @@ class hs_utils {
     static hs_uuid_t gen_system_uuid();
     static std::string encodeBase64(const uint8_t* first, std::size_t size);
     static std::string encodeBase64(const sisl::byte_view& b);
-    template <typename T> static void decodeBase64(const std::string &encoded_data, T out);
-    static std::string decodeBase64(const std::string &encoded_data);
+    template < typename T >
+    static void decodeBase64(const std::string& encoded_data, T out);
+    static std::string decodeBase64(const std::string& encoded_data);
 };
 static constexpr hs_uuid_t INVALID_SYSTEM_UUID{0};
 
diff --git a/src/engine/device/device.h b/src/engine/device/device.h
index aa5d38281..8e7dc06fd 100644
--- a/src/engine/device/device.h
+++ b/src/engine/device/device.h
@@ -450,8 +450,10 @@ class PhysicalDevMetrics : public sisl::MetricsGroupWrapper {
         REGISTER_COUNTER(drive_spurios_events, "Total number of spurious events per drive");
         REGISTER_COUNTER(drive_skipped_chunk_bm_writes, "Total number of skipped writes for chunk bitmap");
 
-        REGISTER_HISTOGRAM(drive_write_latency, "BlkStore drive write latency in us", HistogramBucketsType(OpLatecyBuckets));
-        REGISTER_HISTOGRAM(drive_read_latency, "BlkStore drive read latency in us", HistogramBucketsType(OpLatecyBuckets));
+        REGISTER_HISTOGRAM(drive_write_latency, "BlkStore drive write latency in us",
+                           HistogramBucketsType(OpLatecyBuckets));
+        REGISTER_HISTOGRAM(drive_read_latency, "BlkStore drive read latency in us",
+                           HistogramBucketsType(OpLatecyBuckets));
 
         REGISTER_HISTOGRAM(write_io_sizes, "Write IO Sizes", "io_sizes", {"io_direction", "write"},
                            HistogramBucketsType(ExponentialOfTwoBuckets));
diff --git a/src/engine/homeds/btree/btree.hpp b/src/engine/homeds/btree/btree.hpp
index 67c7e4f4e..18abd369b 100644
--- a/src/engine/homeds/btree/btree.hpp
+++ b/src/engine/homeds/btree/btree.hpp
@@ -742,12 +742,12 @@ class Btree {
      * @return : true if btree is not corrupted.
      *           false if btree is corrupted;
      */
-    bool verify_tree(bool update_debug_bm, bool recursive=false) {
+    bool verify_tree(bool update_debug_bm, bool recursive = false) {
         m_btree_lock.read_lock();
-		LOGINFO("Starting btree verification for: {}", m_btree_cfg.get_name());
+        LOGINFO("Starting btree verification for: {}", m_btree_cfg.get_name());
         bool ret = verify_node(m_root_node, nullptr, -1, update_debug_bm, recursive);
         m_btree_lock.unlock();
-		LOGINFO("Completed btree verification for: {}, result={}", m_btree_cfg.get_name(), ret);
+        LOGINFO("Completed btree verification for: {}, result={}", m_btree_cfg.get_name(), ret);
         return ret;
     }
 
@@ -763,12 +763,12 @@ class Btree {
         uint64_t nodes_not_in_cache;
 
         EvictionStats() :
-            total_nodes_checked(0),
-            nodes_evicted(0),
-            nodes_with_refs(0),
-            nodes_dirty(0),
-            nodes_locked(0),
-            nodes_not_in_cache(0) {}
+                total_nodes_checked(0),
+                nodes_evicted(0),
+                nodes_with_refs(0),
+                nodes_dirty(0),
+                nodes_locked(0),
+                nodes_not_in_cache(0) {}
     };
 
     EvictionStats release_cached_tree() {
@@ -781,8 +781,8 @@ class Btree {
         m_btree_lock.unlock();
 
         LOGINFO("RELEASE_CACHE: Completed for btree: {} - total={} evicted={} with_refs={} not_in_cache={}",
-                m_btree_cfg.get_name(), stats.total_nodes_checked, stats.nodes_evicted,
-                stats.nodes_with_refs, stats.nodes_not_in_cache);
+                m_btree_cfg.get_name(), stats.total_nodes_checked, stats.nodes_evicted, stats.nodes_with_refs,
+                stats.nodes_not_in_cache);
 
         return stats;
     }
@@ -1186,13 +1186,14 @@ class Btree {
     nlohmann::json get_metrics_in_json(bool updated = true) { return m_metrics.get_result_in_json(updated); }
 
 private:
-	bool verify_node(bnodeid_t bnodeid, BtreeNodePtr parent_node, uint32_t indx, bool update_debug_bm, bool recursive=false) {
-		if (recursive) {
+    bool verify_node(bnodeid_t bnodeid, BtreeNodePtr parent_node, uint32_t indx, bool update_debug_bm,
+                     bool recursive = false) {
+        if (recursive) {
             return verify_node_recursive(bnodeid, parent_node, indx, update_debug_bm);
         } else {
             return verify_node_fowarding(bnodeid, parent_node, indx, update_debug_bm);
         }
-	}
+    }
     /**
      * @brief : verify the btree node is corrupted or not;
      *
@@ -1305,7 +1306,8 @@ class Btree {
         }
 
         if (my_node->has_valid_edge()) {
-            success = verify_node_recursive(my_node->get_edge_id(), my_node, my_node->get_total_entries(), update_debug_bm);
+            success =
+                verify_node_recursive(my_node->get_edge_id(), my_node, my_node->get_total_entries(), update_debug_bm);
             if (!success) { goto exit_on_error; }
         }
 
@@ -1343,16 +1345,19 @@ class Btree {
             uint32_t parent_total_entries;
             bool validate_with_parent;
 
-            NodeToVerify(bnodeid_t nid, uint32_t idx, bool hp, const K* pkey, const K* pprev,
-                        uint32_t ptotal, bool validate)
-                : node_id(nid), parent_index(idx), has_parent(hp),
-                  parent_total_entries(ptotal), validate_with_parent(validate) {
+            NodeToVerify(bnodeid_t nid, uint32_t idx, bool hp, const K* pkey, const K* pprev, uint32_t ptotal,
+                         bool validate) :
+                    node_id(nid),
+                    parent_index(idx),
+                    has_parent(hp),
+                    parent_total_entries(ptotal),
+                    validate_with_parent(validate) {
                 if (pkey) parent_key = *pkey;
                 if (pprev) parent_prev_key = *pprev;
             }
         };
 
-        std::queue<NodeToVerify> work_queue;
+        std::queue< NodeToVerify > work_queue;
         work_queue.push(NodeToVerify(bnodeid, indx, false, nullptr, nullptr, 0, false));
 
         while (!work_queue.empty()) {
@@ -1387,13 +1392,15 @@ class Btree {
                     K* pprev = (i > 0) ? &prev_key : nullptr;
                     bool validate = (my_node->get_total_entries() != i);
 
-                    work_queue.push(NodeToVerify(child.bnode_id(), i, true, &key, pprev,
-                                                 my_node->get_total_entries(), validate));
+                    work_queue.push(
+                        NodeToVerify(child.bnode_id(), i, true, &key, pprev, my_node->get_total_entries(), validate));
 
                     if (i > 0) {
                         BT_LOG_ASSERT_CMP(prev_key.compare(&key), <, 0, my_node);
                         if (prev_key.compare(&key) >= 0) {
-                            LOGERROR("VERIFY_NODE_FAIL: Interior node key ordering violation at index {}: prev_key >= key", i);
+                            LOGERROR(
+                                "VERIFY_NODE_FAIL: Interior node key ordering violation at index {}: prev_key >= key",
+                                i);
                             unlock_node(my_node, acq_lock);
                             return false;
                         }
@@ -1403,7 +1410,9 @@ class Btree {
                 if (my_node->is_leaf() && i > 0) {
                     BT_LOG_ASSERT_CMP(prev_key.compare_start(&key), <, 0, my_node);
                     if (prev_key.compare_start(&key) >= 0) {
-                        LOGERROR("VERIFY_NODE_FAIL: Leaf node key ordering violation at index {}: prev_key.compare_start(key) >= 0", i);
+                        LOGERROR("VERIFY_NODE_FAIL: Leaf node key ordering violation at index {}: "
+                                 "prev_key.compare_start(key) >= 0",
+                                 i);
                         unlock_node(my_node, acq_lock);
                         return false;
                     }
@@ -1417,15 +1426,15 @@ class Btree {
 
                 if (!my_node->is_leaf()) {
                     if (last_key.compare(&current.parent_key) != 0) {
-                        LOGERROR("Interior node last key {} != parent key {}",
-                                last_key.to_string(), current.parent_key.to_string());
+                        LOGERROR("Interior node last key {} != parent key {}", last_key.to_string(),
+                                 current.parent_key.to_string());
                         unlock_node(my_node, acq_lock);
                         return false;
                     }
                 } else {
                     if (last_key.compare(&current.parent_key) > 0) {
-                        LOGERROR("Leaf node last key {} > parent key {}",
-                                last_key.to_string(), current.parent_key.to_string());
+                        LOGERROR("Leaf node last key {} > parent key {}", last_key.to_string(),
+                                 current.parent_key.to_string());
                         unlock_node(my_node, acq_lock);
                         return false;
                     }
@@ -1442,8 +1451,8 @@ class Btree {
                 my_node->get_nth_key(0, &first_key, false);
 
                 if (first_key.compare(&current.parent_prev_key) <= 0) {
-                    LOGERROR("First key {} <= parent prev key {}",
-                            first_key.to_string(), current.parent_prev_key.to_string());
+                    LOGERROR("First key {} <= parent prev key {}", first_key.to_string(),
+                             current.parent_prev_key.to_string());
                     unlock_node(my_node, acq_lock);
                     return false;
                 }
@@ -1458,8 +1467,8 @@ class Btree {
             if (my_node->has_valid_edge()) {
                 K last_key;
                 my_node->get_nth_key(my_node->get_total_entries() - 1, &last_key, false);
-                work_queue.push(NodeToVerify(my_node->get_edge_id(), my_node->get_total_entries(),
-                                             true, &last_key, &last_key, my_node->get_total_entries(), false));
+                work_queue.push(NodeToVerify(my_node->get_edge_id(), my_node->get_total_entries(), true, &last_key,
+                                             &last_key, my_node->get_total_entries(), false));
             }
 
             unlock_node(my_node, acq_lock);
@@ -1469,7 +1478,7 @@ class Btree {
     }
 
     void release_cached_nodes_recursive(bnodeid_t root_bnodeid, EvictionStats& stats) {
-        std::queue<bnodeid_t> work_queue;
+        std::queue< bnodeid_t > work_queue;
         work_queue.push(root_bnodeid);
 
         while (!work_queue.empty()) {
@@ -1486,16 +1495,14 @@ class Btree {
                 continue;
             }
 
-            std::vector<bnodeid_t> child_ids;
+            std::vector< bnodeid_t > child_ids;
             if (!my_node->is_leaf()) {
                 for (uint32_t i = 0; i < my_node->get_total_entries(); ++i) {
                     BtreeNodeInfo child;
                     my_node->get(i, &child, false);
                     child_ids.push_back(child.bnode_id());
                 }
-                if (my_node->has_valid_edge()) {
-                    child_ids.push_back(my_node->get_edge_id());
-                }
+                if (my_node->has_valid_edge()) { child_ids.push_back(my_node->get_edge_id()); }
             }
 
             for (const auto& child_id : child_ids) {
diff --git a/src/engine/homeds/btree/btree_internal.h b/src/engine/homeds/btree/btree_internal.h
index bc7d8c395..18894a425 100644
--- a/src/engine/homeds/btree/btree_internal.h
+++ b/src/engine/homeds/btree/btree_internal.h
@@ -108,7 +108,7 @@ struct blkalloc_cp_id;
 #define BT_DBG_ASSERT_CMP(...) BT_ASSERT_CMP(DEBUG_ASSERT_CMP, ##__VA_ARGS__)
 #define BT_REL_ASSERT_CMP(...) BT_ASSERT_CMP(RELEASE_ASSERT_CMP, ##__VA_ARGS__)
 #define BT_LOG_ASSERT_CMP(...) BT_ASSERT_CMP(RELEASE_ASSERT_CMP, ##__VA_ARGS__)
-//#define BT_LOG_ASSERT_CMP(...) BT_ASSERT_CMP(LOGMSG, ##__VA_ARGS__)
+// #define BT_LOG_ASSERT_CMP(...) BT_ASSERT_CMP(LOGMSG, ##__VA_ARGS__)
 
 #define MAX_ADJANCENT_INDEX 3
 
@@ -152,7 +152,7 @@ struct btree_cp : public boost::intrusive_ref_counter< btree_cp > {
     seq_id_t end_seqid = -1;   // inclusive
     cp_comp_callback cb;
     homestore::blkid_list_ptr free_blkid_list;
-    btree_cp() : ref_cnt(1), btree_size(0){};
+    btree_cp() : ref_cnt(1), btree_size(0) {};
     ~btree_cp() {}
 
     std::string to_string() const {
@@ -453,7 +453,7 @@ struct BtreeQueryCursor {
         return b;
     };
 
-    BtreeQueryCursor(){};
+    BtreeQueryCursor() {};
     std::string to_string() const {
         if (m_last_key) {
             return (m_last_key->to_string());
diff --git a/src/engine/homeds/btree/btree_node.h b/src/engine/homeds/btree/btree_node.h
index 56bac878d..5b7230975 100644
--- a/src/engine/homeds/btree/btree_node.h
+++ b/src/engine/homeds/btree/btree_node.h
@@ -45,7 +45,7 @@ struct transient_hdr_t {
             ,
             is_lock(-1)
 #endif
-                {};
+    {};
 };
 
 template < btree_node_type NodeType, typename K, typename V >
diff --git a/src/engine/homeds/btree/mem_btree.hpp b/src/engine/homeds/btree/mem_btree.hpp
index 279dd435b..956c77f0e 100644
--- a/src/engine/homeds/btree/mem_btree.hpp
+++ b/src/engine/homeds/btree/mem_btree.hpp
@@ -72,7 +72,7 @@ class MemBtreeStore {
         return nullptr;
     }
     static void create_done(MemBtreeStore* store, bnodeid_t m_root_node);
-    static void update_sb(MemBtreeStore* store, btree_super_block& sb, btree_cp_sb* cp_sb, bool is_recovery){};
+    static void update_sb(MemBtreeStore* store, btree_super_block& sb, btree_cp_sb* cp_sb, bool is_recovery) {};
 
     static boost::intrusive_ptr< MemBtreeNode >
     alloc_node(MemBtreeStore* store, bool is_leaf,
diff --git a/src/engine/homeds/btree/prefix_node.hpp b/src/engine/homeds/btree/prefix_node.hpp
index 19fe714ae..256a1be09 100644
--- a/src/engine/homeds/btree/prefix_node.hpp
+++ b/src/engine/homeds/btree/prefix_node.hpp
@@ -45,9 +45,7 @@ class BtreePrefixNode : public BtreeAbstractNode {
         for (uint16_t i = ind; i < getTotalEntries(); i++) {
             BtreePrefixRecord* rec = getRecordPtr(ind);
             uint16_t prefixInd = rec->getPrefixRecordIndex();
-            if (prefixInd >= ind) {
-                rec->setPrefixRecordIndex(prefixInd + 1);
-            }
+            if (prefixInd >= ind) { rec->setPrefixRecordIndex(prefixInd + 1); }
 
             rec->getDataOffset()
         }
diff --git a/src/engine/homeds/btree/writeBack_cache.hpp b/src/engine/homeds/btree/writeBack_cache.hpp
index d22a3f3c1..bbec46876 100644
--- a/src/engine/homeds/btree/writeBack_cache.hpp
+++ b/src/engine/homeds/btree/writeBack_cache.hpp
@@ -131,7 +131,7 @@ class WriteBackCacheBuffer : public CacheBuffer< homestore::BlkId > {
                 bcp(nullptr),
                 req_q(),
                 dependent_cnt(1),
-                m_mem(nullptr){};
+                m_mem(nullptr) {};
     };
 
     //*************************************************** WriteBackCacheBuffer *******************************
@@ -537,7 +537,7 @@ class WriteBackCache : public std::enable_shared_from_this< WriteBackCache< K, V
         // we are done with this wb_req
         HS_REL_ASSERT_EQ(wb_req, wb_req->bn->req[cp_id]);
         wb_req->bn->req[cp_id] = nullptr;
-        
+
         /* req and btree node are pointing to each other which is preventing neither of them to be freed */
         wb_req->bn = nullptr;
 
diff --git a/src/engine/homeds/loadgen/loadgen.hpp b/src/engine/homeds/loadgen/loadgen.hpp
index f1b7c4633..244a60c3a 100644
--- a/src/engine/homeds/loadgen/loadgen.hpp
+++ b/src/engine/homeds/loadgen/loadgen.hpp
@@ -34,7 +34,7 @@
 #include <sisl/utility/atomic_counter.hpp>
 #include <sisl/utility/enum.hpp>
 
-//#include "iomgr_executor.hpp"
+// #include "iomgr_executor.hpp"
 #include "keyset.hpp"
 #include "loadgen_common.hpp"
 
diff --git a/src/engine/homeds/memory/chunk_allocator.hpp b/src/engine/homeds/memory/chunk_allocator.hpp
index 2c51aa379..25c82e5d5 100644
--- a/src/engine/homeds/memory/chunk_allocator.hpp
+++ b/src/engine/homeds/memory/chunk_allocator.hpp
@@ -93,7 +93,7 @@ class ChunkMemAllocator : public AbstractMemAllocator {
     }
 
     virtual ~ChunkMemAllocator() {
-        if (m_base_ptr) { delete[](m_base_ptr); }
+        if (m_base_ptr) { delete[] (m_base_ptr); }
     }
 
     // Provides the metadata blk size. This metadata blk can be used by the caller to put anything it wants after
diff --git a/src/engine/homeds/memory/memory.old/chunk_allocator2.hpp b/src/engine/homeds/memory/memory.old/chunk_allocator2.hpp
index 5eff92c9d..028fef8a2 100644
--- a/src/engine/homeds/memory/memory.old/chunk_allocator2.hpp
+++ b/src/engine/homeds/memory/memory.old/chunk_allocator2.hpp
@@ -78,9 +78,7 @@ class ChunkMemAllocator {
     }
 
     virtual ~ChunkMemAllocator() {
-        if (m_base_ptr) {
-            delete[](m_base_ptr);
-        }
+        if (m_base_ptr) { delete[] (m_base_ptr); }
     }
 
     // Provides the metadata blk size. This metadata blk can be used by the caller to put anything it wants after
@@ -96,24 +94,18 @@ class ChunkMemAllocator {
     uint8_t* allocate(uint32_t size_needed, uint8_t** meta_blk = nullptr) {
         MemBlk blk;
 
-        if (size_needed > ChunkSize) {
-            return nullptr;
-        }
+        if (size_needed > ChunkSize) { return nullptr; }
 
         chunk_pool_header* hdr = nullptr;
         hdr = alloc_header();
-        if (hdr == nullptr) {
-            return hdr;
-        }
+        if (hdr == nullptr) { return hdr; }
 
 #ifdef CHUNK_MEMPOOL_DEBUG
         printf("%p: ChunkMemAllocator: %p Alloc id=0x%x refcnt=%d size=%u top=0x%llx\n", pthread_self(), this, hdr->id,
                hdr->refcnt.load(), m_entrySize, m_top.load());
 #endif
 
-        if (meta_blk) {
-            *meta_blk = (uint8_t*)hdr;
-        }
+        if (meta_blk) { *meta_blk = (uint8_t*)hdr; }
         return hdr_to_mem(hdr);
     }
 
@@ -148,9 +140,7 @@ class ChunkMemAllocator {
             top_id = m_top.load(std::memory_order_release);
             uint32_t id = get_id_from_top_id(top_id);
 
-            if (id == CHUNKID_INVALID) {
-                return nullptr;
-            }
+            if (id == CHUNKID_INVALID) { return nullptr; }
 
             hdr = id_to_hdr(id);
             uint32_t gen = m_gen.fetch_add(1, std::memory_order_acq_rel);
diff --git a/src/engine/homeds/memory/memory.old/mem_allocator.hpp b/src/engine/homeds/memory/memory.old/mem_allocator.hpp
index 18985c5a0..7d298c18b 100644
--- a/src/engine/homeds/memory/memory.old/mem_allocator.hpp
+++ b/src/engine/homeds/memory/memory.old/mem_allocator.hpp
@@ -133,16 +133,12 @@ class mem_allocator {
     //// Fast_Mempool related methods. These are unsafe methods /////
     void free(mempool_header* hdr) {
         fast_mempool* pool = get_owner_pool(hdr);
-        if (pool) {
-            return pool->free(hdr);
-        }
+        if (pool) { return pool->free(hdr); }
     }
 
     mem_id_t to_id(uint8_t* mem) {
         fast_mempool* pool = get_owner_pool(mem);
-        if (pool) {
-            return pool->to_mem_id(mem);
-        }
+        if (pool) { return pool->to_mem_id(mem); }
         return mem_id_t::form(INVALID_MEM_ID);
     }
 
@@ -198,9 +194,7 @@ class mem_allocator {
 
     mempool* get_owner_pool(uint8_t* mem) {
         for (auto i = 0; i < m_pools.size(); i++) {
-            if (m_pools[i].pool->owns(mem)) {
-                return (m_pools[i].pool);
-            }
+            if (m_pools[i].pool->owns(mem)) { return (m_pools[i].pool); }
         }
         return nullptr;
     }
@@ -213,9 +207,7 @@ class mem_allocator {
      */
     fast_mempool* get_owner_pool(mempool_header* hdr) {
         for (auto i = 0; i < m_pools.size(); i++) {
-            if (m_pools[i].pool->owns(hdr)) {
-                return (m_pools[i].pool);
-            }
+            if (m_pools[i].pool->owns(hdr)) { return (m_pools[i].pool); }
         }
         return nullptr;
     }
diff --git a/src/engine/homeds/memory/memory.old/smart_ptr.hpp b/src/engine/homeds/memory/memory.old/smart_ptr.hpp
index c9d035e8a..e9ef78a54 100644
--- a/src/engine/homeds/memory/memory.old/smart_ptr.hpp
+++ b/src/engine/homeds/memory/memory.old/smart_ptr.hpp
@@ -72,9 +72,7 @@ struct smart_ptr_block {
             m_ptr = other.m_ptr;
             oldval = m_ptr.load(std::memory_order_acquire);
             tp = tagged_ptr(oldval);
-            if (tp.get_ptr() == nullptr) {
-                break;
-            }
+            if (tp.get_ptr() == nullptr) { break; }
             tp.inc_tag();
             newval = tp.get_packed();
         } while (!(m_ptr.compare_exchange_weak(oldval, newval, std::memory_order_acq_rel)));
@@ -124,9 +122,7 @@ class atomic_smart_ptr {
     /// @brief this reset releases its ownership
     void reset(void) noexcept {
 
-        if (m_ptr->release() == true) {
-            fds::mem_allocator::instance()->free((mempool_header*)m_ptr.load());
-        }
+        if (m_ptr->release() == true) { fds::mem_allocator::instance()->free((mempool_header*)m_ptr.load()); }
     }
 
     // underlying pointer operations :
@@ -144,9 +140,7 @@ class atomic_smart_ptr {
     }
 
     inline T* get(void) {
-        if (m_ptr == nullptr) {
-            return nullptr;
-        }
+        if (m_ptr == nullptr) { return nullptr; }
 
         // no assert, can return NULL
         mempool_header* hdr = (mempool_header*)(m_ptr.load());
diff --git a/src/engine/homeds/memory/mempiece.hpp b/src/engine/homeds/memory/mempiece.hpp
index 509b14ba6..3a5c1ca3d 100644
--- a/src/engine/homeds/memory/mempiece.hpp
+++ b/src/engine/homeds/memory/mempiece.hpp
@@ -37,8 +37,8 @@
 #include "engine/common/homestore_assert.hpp"
 #include "engine/common/homestore_config.hpp"
 #include "engine/common/homestore_utils.hpp"
-//#include "engine/homestore_base.hpp"
-//#include "tagged_ptr.hpp"
+// #include "engine/homestore_base.hpp"
+// #include "tagged_ptr.hpp"
 #include <sisl/metrics/metrics.hpp>
 
 namespace homeds {
@@ -47,7 +47,7 @@ using namespace homestore; // NOTE: This needs to be removed as it pollutes name
 
 #if 0
 // Tagged pointer implementation of MemPiece
-#define round_off(val, rnd) ((((val)-1) / (rnd)) + 1)
+#define round_off(val, rnd) ((((val) - 1) / (rnd)) + 1)
 
 #pragma pack(1)
 struct mempiece_tag {
diff --git a/src/engine/homeds/tests/loadgen_tests/test_load.cpp b/src/engine/homeds/tests/loadgen_tests/test_load.cpp
index eac0d8d50..2b19a95e6 100644
--- a/src/engine/homeds/tests/loadgen_tests/test_load.cpp
+++ b/src/engine/homeds/tests/loadgen_tests/test_load.cpp
@@ -119,7 +119,7 @@ struct BtreeTest : public ::testing::Test {
     virtual ~BtreeTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -148,7 +148,7 @@ class SSDBtreeTest : public ::testing::Test {
     virtual ~SSDBtreeTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -195,7 +195,7 @@ class SSDBtreeVarKVTest : public ::testing::Test {
     virtual ~SSDBtreeVarKVTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -242,7 +242,7 @@ class MapTest : public ::testing::Test {
     virtual ~MapTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -290,7 +290,7 @@ class FileTest : public ::testing::Test {
     virtual ~FileTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -353,7 +353,7 @@ class VDevTest_RW : public ::testing::Test {
     virtual ~VDevTest_RW() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -402,7 +402,7 @@ class VDevTest_PRW : public ::testing::Test {
     virtual ~VDevTest_PRW() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -451,7 +451,7 @@ class CacheTest : public ::testing::Test {
     virtual ~CacheTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
@@ -477,8 +477,8 @@ class VolumeLoadTest : public ::testing::Test {
     virtual ~VolumeLoadTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
-    virtual void TearDown() override{};
+    virtual void SetUp() override {};
+    virtual void TearDown() override {};
 
 public:
     std::unique_ptr< G_Volume_Test > m_loadgen;
@@ -546,7 +546,7 @@ class LogStoreLoadTest : public ::testing::Test {
     virtual ~LogStoreLoadTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
+    virtual void SetUp() override {};
     virtual void TearDown() override { loadgen.reset(); };
 
 public:
diff --git a/src/engine/homeds/tests/loadgen_tests/valuespecs/cache_value_spec.hpp b/src/engine/homeds/tests/loadgen_tests/valuespecs/cache_value_spec.hpp
index 88351973b..383e01b99 100644
--- a/src/engine/homeds/tests/loadgen_tests/valuespecs/cache_value_spec.hpp
+++ b/src/engine/homeds/tests/loadgen_tests/valuespecs/cache_value_spec.hpp
@@ -48,7 +48,7 @@ class CacheValueBuffer : public homestore::CacheBuffer< CacheKey > {
     CacheValueBuffer& operator=(CacheValueBuffer&&) noexcept = delete;
     virtual ~CacheValueBuffer() override = default;
 
-    virtual void init() override{};
+    virtual void init() override {};
 
     template < typename... Args >
     static CacheValueBuffer* make_object(Args... args) {
diff --git a/src/engine/homeds/tests/test_btree_crud.cpp b/src/engine/homeds/tests/test_btree_crud.cpp
index 2887e7ab3..969fe65c3 100644
--- a/src/engine/homeds/tests/test_btree_crud.cpp
+++ b/src/engine/homeds/tests/test_btree_crud.cpp
@@ -278,7 +278,7 @@ struct SimpleKeyComparator {
 
 #define TOTAL_ENTRIES 100000
 #define TOTAL_OPERS_PER_TEST 500
-//#define NTHREADS 4
+// #define NTHREADS 4
 #define NTHREADS 1
 
 struct BtreeCrudTest : public ::testing::Test {
diff --git a/src/engine/homeds/utility/stats.hpp b/src/engine/homeds/utility/stats.hpp
index f01347794..85f6133f8 100644
--- a/src/engine/homeds/utility/stats.hpp
+++ b/src/engine/homeds/utility/stats.hpp
@@ -44,7 +44,7 @@ class Stats {
         }
     }
 
-    ~Stats() { delete[](m_values); }
+    ~Stats() { delete[] (m_values); }
 
     void set_count(req_stats_index ind, uint64_t val) {
         assert(m_keys[ind].type == COUNTER);
diff --git a/src/engine/homeds/utility/useful_defs.hpp b/src/engine/homeds/utility/useful_defs.hpp
index d9abcf752..b86a24caf 100644
--- a/src/engine/homeds/utility/useful_defs.hpp
+++ b/src/engine/homeds/utility/useful_defs.hpp
@@ -99,12 +99,12 @@ constexpr std::array< char const, N1 + N2 - 1 > const_concat(char const (&a1)[N1
 #define const_concat_string(s1, s2) (&(const_concat(s1, s2)[0]))
 
 template < class P, class M >
-inline size_t offset_of(const M P::*member) {
-    return (size_t) & (reinterpret_cast< P* >(0)->*member);
+inline size_t offset_of(const M P::* member) {
+    return (size_t)&(reinterpret_cast< P* >(0)->*member);
 }
 
 template < class P, class M >
-inline P* container_of(const M* ptr, const M P::*member) {
+inline P* container_of(const M* ptr, const M P::* member) {
     return (P*)((char*)ptr - offset_of(member));
 }
 
diff --git a/src/engine/homestore.hpp b/src/engine/homestore.hpp
index 333f54dda..b83956c13 100644
--- a/src/engine/homestore.hpp
+++ b/src/engine/homestore.hpp
@@ -292,7 +292,7 @@ class HomeStore : public HomeStoreBase {
         const PhysicalDevGroup pdev_group{PhysicalDevGroup::DATA};
         if (vb == nullptr) {
             /* change it to context */
-            struct blkstore_blob blob {};
+            struct blkstore_blob blob{};
             blob.type = blkstore_type::DATA_STORE;
             const uint64_t size{
                 pct_to_size((is_data_drive_hdd() ? hdd_data_blkstore_pct : data_blkstore_pct), pdev_group)};
@@ -318,7 +318,7 @@ class HomeStore : public HomeStoreBase {
         const PhysicalDevGroup pdev_group{PhysicalDevGroup::FAST};
         const auto atomic_phys_page_size{get_indx_mgr_page_size()};
         if (vb == nullptr) {
-            struct blkstore_blob blob {};
+            struct blkstore_blob blob{};
             blob.type = blkstore_type::INDEX_STORE;
             const uint64_t size{
                 pct_to_size((is_data_drive_hdd() ? hdd_indx_blkstore_pct : indx_blkstore_pct), pdev_group)};
@@ -348,7 +348,7 @@ class HomeStore : public HomeStoreBase {
         const PhysicalDevGroup pdev_group{PhysicalDevGroup::META};
         const auto phys_page_size{m_dev_mgr->get_phys_page_size({PhysicalDevGroup::META})};
         if (vb == nullptr) {
-            struct blkstore_blob blob {};
+            struct blkstore_blob blob{};
             blob.type = blkstore_type::META_STORE;
             const uint64_t size{
                 pct_to_size((is_data_drive_hdd() ? hdd_meta_blkstore_pct : meta_blkstore_pct), pdev_group)};
@@ -379,7 +379,7 @@ class HomeStore : public HomeStoreBase {
         const PhysicalDevGroup pdev_group{PhysicalDevGroup::FAST};
         const auto atomic_phys_page_size{m_dev_mgr->get_atomic_page_size({PhysicalDevGroup::FAST})};
         if (vb == nullptr) {
-            struct blkstore_blob blob {};
+            struct blkstore_blob blob{};
             blob.type = blkstore_type::DATA_LOGDEV_STORE;
             const uint64_t size{pct_to_size(
                 (is_data_drive_hdd() ? hdd_data_logdev_blkstore_pct : data_logdev_blkstore_pct), pdev_group)};
@@ -410,7 +410,7 @@ class HomeStore : public HomeStoreBase {
         const auto atomic_phys_page_size{m_dev_mgr->get_atomic_page_size({PhysicalDevGroup::FAST})};
 
         if (vb == nullptr) {
-            struct blkstore_blob blob {};
+            struct blkstore_blob blob{};
             blob.type = blkstore_type::CTRL_LOGDEV_STORE;
             const uint64_t size{pct_to_size(
                 (is_data_drive_hdd() ? hdd_ctrl_logdev_blkstore_pct : ctrl_logdev_blkstore_pct), pdev_group)};
diff --git a/src/engine/index/checkpoint.hpp b/src/engine/index/checkpoint.hpp
index a934c581b..42ab500f5 100644
--- a/src/engine/index/checkpoint.hpp
+++ b/src/engine/index/checkpoint.hpp
@@ -76,7 +76,7 @@ struct cp_base {
     /* callback when cp is done */
     std::vector< cp_done_cb > cb_list;
 
-    cp_base() : enter_cnt(0), cb_list(0){};
+    cp_base() : enter_cnt(0), cb_list(0) {};
     std::string to_string() {
         return fmt::format("[cp_status={}, enter_cnt={}]", enum_name(cp_status.load()), enter_cnt.load());
     }
diff --git a/src/engine/index/indx_mgr.hpp b/src/engine/index/indx_mgr.hpp
index bfb56f9b6..f6c0fb29f 100644
--- a/src/engine/index/indx_mgr.hpp
+++ b/src/engine/index/indx_mgr.hpp
@@ -262,7 +262,7 @@ struct indx_cp : public boost::intrusive_ref_counter< indx_cp > {
 
     int state() const { return flags; }
     seq_id_t get_max_seqid() const { return 0; }
-    void set_max_seqid(const seq_id_t seqid){};
+    void set_max_seqid(const seq_id_t seqid) {};
 
     std::string to_string() const {
         return fmt::format(
@@ -328,7 +328,7 @@ struct indx_cp_base_sb {
     btree_cp_sb acp_sb; // active cp superblock
     btree_cp_sb dcp_sb; // diff cp_superblock
     indx_cp_base_sb(const boost::uuids::uuid uuid) : uuid{uuid} {};
-    indx_cp_base_sb(){};
+    indx_cp_base_sb() {};
     std::string to_string() const {
         return fmt::format("active_cp_cnt={} active_data_seqid={} diff_cp_cnt={} diff_data_seqid={} blkalloc_cp_id={} "
                            "indx_size={} btree acp={}",
@@ -438,6 +438,7 @@ ENUM(indx_recovery_state, uint8_t, create_sb_st, create_indx_tbl_st, create_firs
 /* this class defines all the static members of indx_mgr */
 class StaticIndxMgr {
     friend class HomeBlks;
+
 public:
     /*********************** static public functions **********************/
 
diff --git a/src/engine/meta/test_meta_blk_mgr.cpp b/src/engine/meta/test_meta_blk_mgr.cpp
index 779f0f74d..4229dd51e 100644
--- a/src/engine/meta/test_meta_blk_mgr.cpp
+++ b/src/engine/meta/test_meta_blk_mgr.cpp
@@ -156,9 +156,9 @@ class VMetaBlkMgrTest : public ::testing::Test {
     virtual ~VMetaBlkMgrTest() override = default;
 
 protected:
-    void SetUp() override{};
+    void SetUp() override {};
 
-    void TearDown() override{};
+    void TearDown() override {};
 
 public:
     [[nodiscard]] uint64_t get_elapsed_time(const Clock::time_point& start) {
@@ -719,17 +719,15 @@ TEST_F(VMetaBlkMgrTest, random_load_test) {
 TEST_F(VMetaBlkMgrTest, get_status_test) {
     start_homestore(SISL_OPTIONS["num_devs"].as< uint32_t >(),
                     SISL_OPTIONS["dev_size_gb"].as< uint64_t >() * 1024 * 1024 * 1024, gp.num_threads);
-    auto validate_status = [this](std::string type, uint64_t size, bool expected_error=false) {
+    auto validate_status = [this](std::string type, uint64_t size, bool expected_error = false) {
         sisl::status_request status_req;
-        status_req.obj_name = "MetaBlk_"+type;
+        status_req.obj_name = "MetaBlk_" + type;
         status_req.verbose_level = 3;
         const auto sobject_mgr = HomeStoreBase::safe_instance()->sobject_mgr();
         const auto status_resp = sobject_mgr->get_status(status_req);
         LOGINFO("get_status returned : {}", status_resp.json.dump());
-        if(status_resp.json.contains("error")) {
-             ASSERT_TRUE(expected_error);
-        }
-        if(status_resp.json.contains("[0] content")){
+        if (status_resp.json.contains("error")) { ASSERT_TRUE(expected_error); }
+        if (status_resp.json.contains("[0] content")) {
             auto encoded_content = status_resp.json["[0] content"];
             const auto decode_content = hs_utils::decodeBase64(encoded_content);
             auto val_content = hs_utils::encodeBase64(reinterpret_cast< const unsigned char* >(decode_content.data()),
@@ -744,7 +742,7 @@ TEST_F(VMetaBlkMgrTest, get_status_test) {
     m_start_time = Clock::now();
     register_client();
     [[maybe_unused]] auto write_result = do_sb_write(false, 500);
-    validate_status(mtype, 500 ); // check the size written is correct as well as encode/decode
+    validate_status(mtype, 500); // check the size written is correct as well as encode/decode
 
     mtype = "Test_Write2";
     reset_counters();
@@ -764,10 +762,9 @@ TEST_F(VMetaBlkMgrTest, get_status_test) {
     reset_counters();
     register_client();
     write_result = do_sb_write(false, 100);
-    validate_status(mtype, 500, true); // Since the size is 100, the former size must be wrong
+    validate_status(mtype, 500, true);        // Since the size is 100, the former size must be wrong
     validate_status("ERROR_TYPE", 500, true); // An error type also must results in error
 
-
     this->shutdown();
 }
 
diff --git a/src/homeblks/home_blks.cpp b/src/homeblks/home_blks.cpp
index 1120a385b..3054b95ae 100644
--- a/src/homeblks/home_blks.cpp
+++ b/src/homeblks/home_blks.cpp
@@ -635,11 +635,11 @@ bool HomeBlks::verify_index_bm() {
     return true;
 }
 
-std::map<boost::uuids::uuid, uint64_t> HomeBlks::get_used_size(const VolumePtr& vol) {
+std::map< boost::uuids::uuid, uint64_t > HomeBlks::get_used_size(const VolumePtr& vol) {
     /* Update per volume status */
-    std::map<boost::uuids::uuid, uint64_t> utils_map;
+    std::map< boost::uuids::uuid, uint64_t > utils_map;
     std::unique_lock< std::recursive_mutex > lg(m_vol_lock);
-    if (vol == nullptr){
+    if (vol == nullptr) {
         auto it{m_volume_map.begin()};
         while (it != m_volume_map.end()) {
             const VolumePtr& vol{it->second};
@@ -649,7 +649,7 @@ std::map<boost::uuids::uuid, uint64_t> HomeBlks::get_used_size(const VolumePtr&
     } else {
         utils_map[vol->get_uuid()] = vol->get_used_size().used_total_size;
     }
-   return  utils_map;
+    return utils_map;
 }
 
 sisl::status_response HomeBlks::get_status(const sisl::status_request& request) {
@@ -1131,12 +1131,8 @@ void HomeBlks::vol_recovery_start_phase2() {
             total_cache_release_time_ms += cache_release_time_ms;
             LOGINFO("RELEASE_CACHE: Eviction stats for volume: {} - "
                     "total_checked={} evicted={} with_refs={} not_in_cache={} time_ms={}",
-                    it->second->get_name(),
-                    eviction_stats.total_nodes_checked,
-                    eviction_stats.nodes_evicted,
-                    eviction_stats.nodes_with_refs,
-                    eviction_stats.nodes_not_in_cache,
-                    cache_release_time_ms);
+                    it->second->get_name(), eviction_stats.total_nodes_checked, eviction_stats.nodes_evicted,
+                    eviction_stats.nodes_with_refs, eviction_stats.nodes_not_in_cache, cache_release_time_ms);
         }
     }
 
diff --git a/src/homeblks/home_blks.hpp b/src/homeblks/home_blks.hpp
index d23692504..97f470901 100644
--- a/src/homeblks/home_blks.hpp
+++ b/src/homeblks/home_blks.hpp
@@ -128,13 +128,13 @@ typedef WriteBackCacheBuffer< MappingKey, MappingValue, btree_node_type::VAR_VAL
     BLKSTORE_BUFFER_TYPE;
 
 struct HomeBlksRecoveryStats {
-    Clock::time_point m_start;        // recovery start time
-    uint64_t m_phase0_ms{0};          // time spent in phase0: from init to receipt of meta_blk_recovery_comp_cb;
-    uint64_t m_phase1_ms{0};          // time spent in phase1: volume Phase 1
-    uint64_t m_phase2_ms{0};          // time spent in phase2: volume Phase 2
-    uint64_t m_log_store_ms{0};       // time spent in logstore recovery
-    uint64_t m_cache_release_ms{0};   // time spent releasing cached nodes after recovery
-    uint64_t m_total_ms{0};           // total: from metablk notify homeblks of comp_cb to init_done;
+    Clock::time_point m_start;      // recovery start time
+    uint64_t m_phase0_ms{0};        // time spent in phase0: from init to receipt of meta_blk_recovery_comp_cb;
+    uint64_t m_phase1_ms{0};        // time spent in phase1: volume Phase 1
+    uint64_t m_phase2_ms{0};        // time spent in phase2: volume Phase 2
+    uint64_t m_log_store_ms{0};     // time spent in logstore recovery
+    uint64_t m_cache_release_ms{0}; // time spent releasing cached nodes after recovery
+    uint64_t m_total_ms{0};         // total: from metablk notify homeblks of comp_cb to init_done;
 
     void phase0_done() { m_phase0_ms = get_elapsed_time_ms(m_start); }
 
@@ -233,7 +233,7 @@ class HomeBlks : public VolInterface, public HomeStore< BLKSTORE_BUFFER_TYPE > {
     virtual const char* get_name(const VolumePtr& vol) override;
     virtual uint64_t get_page_size(const VolumePtr& vol) override;
     virtual uint64_t get_size(const VolumePtr& vol) override;
-    virtual std::map<boost::uuids::uuid, uint64_t> get_used_size(const VolumePtr& vol) override;
+    virtual std::map< boost::uuids::uuid, uint64_t > get_used_size(const VolumePtr& vol) override;
     virtual boost::uuids::uuid get_uuid(VolumePtr vol) override;
     virtual sisl::blob at_offset(const blk_buf_t& buf, uint32_t offset) override;
 
diff --git a/src/homeblks/homeblks_http_server.cpp b/src/homeblks/homeblks_http_server.cpp
index f7bffcd92..90d53be6c 100644
--- a/src/homeblks/homeblks_http_server.cpp
+++ b/src/homeblks/homeblks_http_server.cpp
@@ -155,9 +155,10 @@ void HomeBlksHttpServer::set_log_level(const Pistache::Rest::Request& request,
 
     response.send(Pistache::Http::Code::Ok, resp);
 }
-void HomeBlksHttpServer::get_utilization(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response)
-{
-    const std::string vol_uuid = request.hasParam(":volumeUUID") ? request.param(":volumeUUID").as<std::string>():"";
+void HomeBlksHttpServer::get_utilization(const Pistache::Rest::Request& request,
+                                         Pistache::Http::ResponseWriter response) {
+    const std::string vol_uuid =
+        request.hasParam(":volumeUUID") ? request.param(":volumeUUID").as< std::string >() : "";
 
     VolumePtr vol = nullptr;
     if (vol_uuid.length() != 0) {
@@ -172,7 +173,7 @@ void HomeBlksHttpServer::get_utilization(const Pistache::Rest::Request& request,
     nlohmann::json resp;
     const auto total_data_size = VolInterface::get_instance()->get_system_capacity().initial_total_data_meta_size;
     for (auto [uuid, vol_used] : VolInterface::get_instance()->get_used_size(vol)) {
-        resp[boost::uuids::to_string(uuid)] = std::to_string(static_cast<double> (vol_used)/ total_data_size);
+        resp[boost::uuids::to_string(uuid)] = std::to_string(static_cast< double >(vol_used) / total_data_size);
     }
     response.send(Pistache::Http::Code::Ok, resp.dump());
 }
diff --git a/src/homeblks/volume/mapping.cpp b/src/homeblks/volume/mapping.cpp
index 2df67f0c8..d1ab5beb7 100644
--- a/src/homeblks/volume/mapping.cpp
+++ b/src/homeblks/volume/mapping.cpp
@@ -272,7 +272,9 @@ btree_status_t mapping::put(mapping_op_cntx& cntx, MappingKey& key, MappingValue
 
 uint64_t mapping::get_btree_node_cnt() { return m_bt->get_btree_node_cnt(); }
 void mapping::print_tree() { m_bt->print_tree(); }
-bool mapping::verify_tree(bool update_debug_bm, bool recursive) { return m_bt->verify_tree(update_debug_bm, recursive); }
+bool mapping::verify_tree(bool update_debug_bm, bool recursive) {
+    return m_bt->verify_tree(update_debug_bm, recursive);
+}
 
 sisl::status_response mapping::get_status(const sisl::status_request& request) { return m_bt->get_status(request); }
 
diff --git a/src/homeblks/volume/mapping.hpp b/src/homeblks/volume/mapping.hpp
index 8659a0582..3d788fde8 100644
--- a/src/homeblks/volume/mapping.hpp
+++ b/src/homeblks/volume/mapping.hpp
@@ -378,7 +378,7 @@ class MappingValue : public homeds::btree::BtreeValue, public sisl::ObjLifeCount
 
 public:
     // creates empty array
-    MappingValue() : ObjLifeCounter(){};
+    MappingValue() : ObjLifeCounter() {};
 
     // creates array with one value entry - on heap, does copy. Initializes the value entry with all these params
     MappingValue(const seq_id_t seqid, const BlkId& blkid, const lba_count_t lba_offset, const lba_count_t nlbas,
diff --git a/src/homeblks/volume/snapshot.hpp b/src/homeblks/volume/snapshot.hpp
index 9a98e43aa..1048d558a 100644
--- a/src/homeblks/volume/snapshot.hpp
+++ b/src/homeblks/volume/snapshot.hpp
@@ -27,9 +27,9 @@ class Snapshot {
     Volume* m_volume;
 
 public:
-    Snapshot(Volume* vol, uint64_t snapId, uint64_t seqId) : m_snapId(snapId), m_seqId(seqId), m_volume(vol){};
+    Snapshot(Volume* vol, uint64_t snapId, uint64_t seqId) : m_snapId(snapId), m_seqId(seqId), m_volume(vol) {};
 
-    ~Snapshot(){};
+    ~Snapshot() {};
 
     std::string to_string() {
         std::stringstream ss;
diff --git a/src/homeblks/volume/tests/vol_gtest.cpp b/src/homeblks/volume/tests/vol_gtest.cpp
index d8aa4ef17..920d09505 100644
--- a/src/homeblks/volume/tests/vol_gtest.cpp
+++ b/src/homeblks/volume/tests/vol_gtest.cpp
@@ -633,8 +633,8 @@ class VolTest : public ::testing::Test {
     VolTest& operator=(const VolTest&) = delete;
     VolTest& operator=(VolTest&&) noexcept = delete;
 
-    virtual void SetUp() override{};
-    virtual void TearDown() override{};
+    virtual void SetUp() override {};
+    virtual void TearDown() override {};
 
     void remove_files() {
         /* no need to delete the user created file/disk */
diff --git a/src/homeblks/volume/tests/vol_merge_test.cpp b/src/homeblks/volume/tests/vol_merge_test.cpp
index 1dfe10fb3..b84c987b8 100644
--- a/src/homeblks/volume/tests/vol_merge_test.cpp
+++ b/src/homeblks/volume/tests/vol_merge_test.cpp
@@ -16,7 +16,7 @@
 #include <sisl/logging/logging.h>
 #include <sisl/options/options.h>
 #include <main/vol_interface.hpp>
-//#include <homeblks/home_blks.hpp>
+// #include <homeblks/home_blks.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
 #include <filesystem>
diff --git a/src/homeblks/volume/volume.cpp b/src/homeblks/volume/volume.cpp
index 21b9c144b..4528d42a1 100644
--- a/src/homeblks/volume/volume.cpp
+++ b/src/homeblks/volume/volume.cpp
@@ -921,7 +921,9 @@ volume_child_req_ptr Volume::create_vol_child_req(const BlkId& bid, const volume
 }
 
 void Volume::print_tree() { get_active_indx()->print_tree(); }
-bool Volume::verify_tree(bool update_debug_bm, bool recursive) { return (get_active_indx()->verify_tree(update_debug_bm, recursive)); }
+bool Volume::verify_tree(bool update_debug_bm, bool recursive) {
+    return (get_active_indx()->verify_tree(update_debug_bm, recursive));
+}
 
 sisl::status_response Volume::get_status(const sisl::status_request& request) {
     sisl::status_response response;
diff --git a/src/homeblks/volume/volume.hpp b/src/homeblks/volume/volume.hpp
index 7850f48f2..c400225d6 100644
--- a/src/homeblks/volume/volume.hpp
+++ b/src/homeblks/volume/volume.hpp
@@ -179,8 +179,10 @@ class VolumeMetrics : public sisl::MetricsGroupWrapper {
         REGISTER_GAUGE(volume_index_used_size, "Total Volume index used size");
         REGISTER_GAUGE(volume_state, "Volume state");
 
-        REGISTER_HISTOGRAM(volume_read_latency, "Volume overall read latency", "volume_op_latency", {"op", "read"}, HistogramBucketsType(OpLatecyBuckets));
-        REGISTER_HISTOGRAM(volume_write_latency, "Volume overall write latency", "volume_op_latency", {"op", "write"}, HistogramBucketsType(OpLatecyBuckets));
+        REGISTER_HISTOGRAM(volume_read_latency, "Volume overall read latency", "volume_op_latency", {"op", "read"},
+                           HistogramBucketsType(OpLatecyBuckets));
+        REGISTER_HISTOGRAM(volume_write_latency, "Volume overall write latency", "volume_op_latency", {"op", "write"},
+                           HistogramBucketsType(OpLatecyBuckets));
 #ifndef NDEBUG
         REGISTER_HISTOGRAM(volume_unmap_latency, "Volume overall unmap latency", "volume_op_latency", {"op", "unmap"});
 #endif
@@ -192,7 +194,8 @@ class VolumeMetrics : public sisl::MetricsGroupWrapper {
                            {"op", "read"}, HistogramBucketsType(OpLatecyBuckets));
         REGISTER_HISTOGRAM(volume_map_write_latency, "Volume mapping write latency", "volume_map_op_latency",
                            {"op", "write"}, HistogramBucketsType(OpLatecyBuckets));
-        REGISTER_HISTOGRAM(volume_blkalloc_latency, "Volume block allocation latency (in ns)", HistogramBucketsType(OpLatecyBuckets));
+        REGISTER_HISTOGRAM(volume_blkalloc_latency, "Volume block allocation latency (in ns)",
+                           HistogramBucketsType(OpLatecyBuckets));
         REGISTER_HISTOGRAM(volume_pieces_per_write, "Number of individual pieces per write",
                            HistogramBucketsType(LinearUpto64Buckets));
         REGISTER_COUNTER(volume_read_on_hole, "Number of reads from empty lba");
@@ -324,7 +327,7 @@ class Volume : public std::enable_shared_from_this< Volume > {
     std::atomic< uint64_t > m_err_cnt = 0;
     sisl::atomic_counter< uint64_t > m_vol_ref_cnt = 0; // volume can not be destroy/shutdown until it is not zero
 
-    std::mutex m_sb_lock;                               // lock for updating vol's sb
+    std::mutex m_sb_lock; // lock for updating vol's sb
     sisl::byte_array m_sb_buf;
     indxmgr_stop_cb m_destroy_done_cb;
     std::atomic< bool > m_indx_mgr_destroy_started;
@@ -620,7 +623,7 @@ class Volume : public std::enable_shared_from_this< Volume > {
     void migrate_sb();
     void recovery_start_phase1();
     void recovery_start_phase2();
-    static void fake_reboot(){};
+    static void fake_reboot() {};
     std::shared_ptr< SnapMgr > get_indx_mgr_instance() { return m_indx_mgr; }
     bool is_recovery_done() const {
         // if we are here but m_indx_mgr is nullptr, it means volume instance is created but index recovery is not done
diff --git a/src/homelogstore/log_store_family.cpp b/src/homelogstore/log_store_family.cpp
index 17bb5c196..35f3bc3ee 100644
--- a/src/homelogstore/log_store_family.cpp
+++ b/src/homelogstore/log_store_family.cpp
@@ -31,10 +31,7 @@ namespace homestore {
 SISL_LOGGING_DECL(logstore)
 
 LogStoreFamily::LogStoreFamily(const logstore_family_id_t f_id) :
-        m_family_id{f_id},
-        m_name{std::string("LogDevFamily") + std::to_string(f_id)},
-        m_log_dev{f_id, m_name} {
-}
+        m_family_id{f_id}, m_name{std::string("LogDevFamily") + std::to_string(f_id)}, m_log_dev{f_id, m_name} {}
 
 void LogStoreFamily::start(const bool format, JournalVirtualDev* blk_store) {
     auto hb = HomeStoreBase::safe_instance();
diff --git a/src/homelogstore/log_store_family.hpp b/src/homelogstore/log_store_family.hpp
index b1f4e8e84..6a39bd6af 100644
--- a/src/homelogstore/log_store_family.hpp
+++ b/src/homelogstore/log_store_family.hpp
@@ -79,9 +79,7 @@ class LogStoreFamily {
 
     [[nodiscard]] logdev_key do_device_truncate(const bool dry_run = false);
 
-
 private:
-
     void on_log_store_found(const logstore_id_t store_id, const logstore_superblk& meta);
     void on_io_completion(const logstore_id_t id, const logdev_key ld_key, const logdev_key flush_idx,
                           const uint32_t nremaining_in_batch, void* const ctx);
diff --git a/src/homelogstore/log_store_mgr.cpp b/src/homelogstore/log_store_mgr.cpp
index 0cabdcada..304725428 100644
--- a/src/homelogstore/log_store_mgr.cpp
+++ b/src/homelogstore/log_store_mgr.cpp
@@ -168,8 +168,10 @@ HomeLogStoreMgrMetrics::HomeLogStoreMgrMetrics() : sisl::MetricsGroup("LogStores
                      {"op", "write"});
     REGISTER_COUNTER(logstore_read_count, "Total number of read requests to log stores", "logstore_op_count",
                      {"op", "read"});
-    REGISTER_HISTOGRAM(logstore_append_latency, "Logstore append latency", "logstore_op_latency", {"op", "write"}, HistogramBucketsType(OpLatecyBuckets));
-    REGISTER_HISTOGRAM(logstore_read_latency, "Logstore read latency", "logstore_op_latency", {"op", "read"}, HistogramBucketsType(OpLatecyBuckets));
+    REGISTER_HISTOGRAM(logstore_append_latency, "Logstore append latency", "logstore_op_latency", {"op", "write"},
+                       HistogramBucketsType(OpLatecyBuckets));
+    REGISTER_HISTOGRAM(logstore_read_latency, "Logstore read latency", "logstore_op_latency", {"op", "read"},
+                       HistogramBucketsType(OpLatecyBuckets));
     REGISTER_HISTOGRAM(logdev_flush_size_distribution, "Distribution of flush data size",
                        HistogramBucketsType(ExponentialOfTwoBuckets));
     REGISTER_HISTOGRAM(logdev_flush_records_distribution, "Distribution of num records to flush",
@@ -178,7 +180,8 @@ HomeLogStoreMgrMetrics::HomeLogStoreMgrMetrics() : sisl::MetricsGroup("LogStores
                        HistogramBucketsType(ExponentialOfTwoBuckets));
     REGISTER_HISTOGRAM(logdev_flush_done_msg_time_ns, "Logdev flush completion msg time in ns");
     REGISTER_HISTOGRAM(logdev_post_flush_processing_latency,
-                       "Logdev post flush processing (including callbacks) latency", HistogramBucketsType(OpLatecyBuckets));
+                       "Logdev post flush processing (including callbacks) latency",
+                       HistogramBucketsType(OpLatecyBuckets));
     REGISTER_HISTOGRAM(logdev_fsync_time_us, "Logdev fsync completion time in us");
 
     register_me_to_farm();
diff --git a/src/homelogstore/tests/test_log_store.cpp b/src/homelogstore/tests/test_log_store.cpp
index cc4f5e00a..cce1f38eb 100644
--- a/src/homelogstore/tests/test_log_store.cpp
+++ b/src/homelogstore/tests/test_log_store.cpp
@@ -583,8 +583,8 @@ class LogStoreTest : public ::testing::Test {
     virtual ~LogStoreTest() override = default;
 
 protected:
-    virtual void SetUp() override{};
-    virtual void TearDown() override{};
+    virtual void SetUp() override {};
+    virtual void TearDown() override {};
 
     void init(const uint64_t n_total_records, const std::vector< std::pair< size_t, int > >& inp_freqs = {}) {
         // m_nrecords_waiting_to_issue = std::lround(n_total_records / _batch_size) * _batch_size;
diff --git a/src/replication/repl_log_store/lib/crc32.cc b/src/replication/repl_log_store/lib/crc32.cc
index a201fa93f..922955cf2 100644
--- a/src/replication/repl_log_store/lib/crc32.cc
+++ b/src/replication/repl_log_store/lib/crc32.cc
@@ -44,286 +44,245 @@ const uint32_t crc_lookup[8][256] = {
     }
 #endif
 
-    {
-        0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3,
-        0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91,
-        0x1DB71064,0x6AB020F2,0xF3B97148,0x84BE41DE,0x1ADAD47D,0x6DDDE4EB,0xF4D4B551,0x83D385C7,
-        0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,0x14015C4F,0x63066CD9,0xFA0F3D63,0x8D080DF5,
-        0x3B6E20C8,0x4C69105E,0xD56041E4,0xA2677172,0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B,
-        0x35B5A8FA,0x42B2986C,0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59,
-        0x26D930AC,0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,0xCFBA9599,0xB8BDA50F,
-        0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,0x2F6F7C87,0x58684C11,0xC1611DAB,0xB6662D3D,
-        0x76DC4190,0x01DB7106,0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,0x9FBFE4A5,0xE8B8D433,
-        0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,0x086D3D2D,0x91646C97,0xE6635C01,
-        0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457,
-        0x65B0D9C6,0x12B7E950,0x8BBEB8EA,0xFCB9887C,0x62DD1DDF,0x15DA2D49,0x8CD37CF3,0xFBD44C65,
-        0x4DB26158,0x3AB551CE,0xA3BC0074,0xD4BB30E2,0x4ADFA541,0x3DD895D7,0xA4D1C46D,0xD3D6F4FB,
-        0x4369E96A,0x346ED9FC,0xAD678846,0xDA60B8D0,0x44042D73,0x33031DE5,0xAA0A4C5F,0xDD0D7CC9,
-        0x5005713C,0x270241AA,0xBE0B1010,0xC90C2086,0x5768B525,0x206F85B3,0xB966D409,0xCE61E49F,
-        0x5EDEF90E,0x29D9C998,0xB0D09822,0xC7D7A8B4,0x59B33D17,0x2EB40D81,0xB7BD5C3B,0xC0BA6CAD,
-        0xEDB88320,0x9ABFB3B6,0x03B6E20C,0x74B1D29A,0xEAD54739,0x9DD277AF,0x04DB2615,0x73DC1683,
-        0xE3630B12,0x94643B84,0x0D6D6A3E,0x7A6A5AA8,0xE40ECF0B,0x9309FF9D,0x0A00AE27,0x7D079EB1,
-        0xF00F9344,0x8708A3D2,0x1E01F268,0x6906C2FE,0xF762575D,0x806567CB,0x196C3671,0x6E6B06E7,
-        0xFED41B76,0x89D32BE0,0x10DA7A5A,0x67DD4ACC,0xF9B9DF6F,0x8EBEEFF9,0x17B7BE43,0x60B08ED5,
-        0xD6D6A3E8,0xA1D1937E,0x38D8C2C4,0x4FDFF252,0xD1BB67F1,0xA6BC5767,0x3FB506DD,0x48B2364B,
-        0xD80D2BDA,0xAF0A1B4C,0x36034AF6,0x41047A60,0xDF60EFC3,0xA867DF55,0x316E8EEF,0x4669BE79,
-        0xCB61B38C,0xBC66831A,0x256FD2A0,0x5268E236,0xCC0C7795,0xBB0B4703,0x220216B9,0x5505262F,
-        0xC5BA3BBE,0xB2BD0B28,0x2BB45A92,0x5CB36A04,0xC2D7FFA7,0xB5D0CF31,0x2CD99E8B,0x5BDEAE1D,
-        0x9B64C2B0,0xEC63F226,0x756AA39C,0x026D930A,0x9C0906A9,0xEB0E363F,0x72076785,0x05005713,
-        0x95BF4A82,0xE2B87A14,0x7BB12BAE,0x0CB61B38,0x92D28E9B,0xE5D5BE0D,0x7CDCEFB7,0x0BDBDF21,
-        0x86D3D2D4,0xF1D4E242,0x68DDB3F8,0x1FDA836E,0x81BE16CD,0xF6B9265B,0x6FB077E1,0x18B74777,
-        0x88085AE6,0xFF0F6A70,0x66063BCA,0x11010B5C,0x8F659EFF,0xF862AE69,0x616BFFD3,0x166CCF45,
-        0xA00AE278,0xD70DD2EE,0x4E048354,0x3903B3C2,0xA7672661,0xD06016F7,0x4969474D,0x3E6E77DB,
-        0xAED16A4A,0xD9D65ADC,0x40DF0B66,0x37D83BF0,0xA9BCAE53,0xDEBB9EC5,0x47B2CF7F,0x30B5FFE9,
-        0xBDBDF21C,0xCABAC28A,0x53B39330,0x24B4A3A6,0xBAD03605,0xCDD70693,0x54DE5729,0x23D967BF,
-        0xB3667A2E,0xC4614AB8,0x5D681B02,0x2A6F2B94,0xB40BBE37,0xC30C8EA1,0x5A05DF1B,0x2D02EF8D },
+    {0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832,
+     0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
+     0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A,
+     0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+     0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
+     0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+     0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
+     0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+     0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4,
+     0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+     0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074,
+     0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+     0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525,
+     0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
+     0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
+     0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+     0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76,
+     0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
+     0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6,
+     0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+     0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
+     0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
+     0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7,
+     0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+     0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
+     0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
+     0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330,
+     0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+     0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D},
 
-    {
-        0x00000000,0x191B3141,0x32366282,0x2B2D53C3,0x646CC504,0x7D77F445,0x565AA786,0x4F4196C7,
-        0xC8D98A08,0xD1C2BB49,0xFAEFE88A,0xE3F4D9CB,0xACB54F0C,0xB5AE7E4D,0x9E832D8E,0x87981CCF,
-        0x4AC21251,0x53D92310,0x78F470D3,0x61EF4192,0x2EAED755,0x37B5E614,0x1C98B5D7,0x05838496,
-        0x821B9859,0x9B00A918,0xB02DFADB,0xA936CB9A,0xE6775D5D,0xFF6C6C1C,0xD4413FDF,0xCD5A0E9E,
-        0x958424A2,0x8C9F15E3,0xA7B24620,0xBEA97761,0xF1E8E1A6,0xE8F3D0E7,0xC3DE8324,0xDAC5B265,
-        0x5D5DAEAA,0x44469FEB,0x6F6BCC28,0x7670FD69,0x39316BAE,0x202A5AEF,0x0B07092C,0x121C386D,
-        0xDF4636F3,0xC65D07B2,0xED705471,0xF46B6530,0xBB2AF3F7,0xA231C2B6,0x891C9175,0x9007A034,
-        0x179FBCFB,0x0E848DBA,0x25A9DE79,0x3CB2EF38,0x73F379FF,0x6AE848BE,0x41C51B7D,0x58DE2A3C,
-        0xF0794F05,0xE9627E44,0xC24F2D87,0xDB541CC6,0x94158A01,0x8D0EBB40,0xA623E883,0xBF38D9C2,
-        0x38A0C50D,0x21BBF44C,0x0A96A78F,0x138D96CE,0x5CCC0009,0x45D73148,0x6EFA628B,0x77E153CA,
-        0xBABB5D54,0xA3A06C15,0x888D3FD6,0x91960E97,0xDED79850,0xC7CCA911,0xECE1FAD2,0xF5FACB93,
-        0x7262D75C,0x6B79E61D,0x4054B5DE,0x594F849F,0x160E1258,0x0F152319,0x243870DA,0x3D23419B,
-        0x65FD6BA7,0x7CE65AE6,0x57CB0925,0x4ED03864,0x0191AEA3,0x188A9FE2,0x33A7CC21,0x2ABCFD60,
-        0xAD24E1AF,0xB43FD0EE,0x9F12832D,0x8609B26C,0xC94824AB,0xD05315EA,0xFB7E4629,0xE2657768,
-        0x2F3F79F6,0x362448B7,0x1D091B74,0x04122A35,0x4B53BCF2,0x52488DB3,0x7965DE70,0x607EEF31,
-        0xE7E6F3FE,0xFEFDC2BF,0xD5D0917C,0xCCCBA03D,0x838A36FA,0x9A9107BB,0xB1BC5478,0xA8A76539,
-        0x3B83984B,0x2298A90A,0x09B5FAC9,0x10AECB88,0x5FEF5D4F,0x46F46C0E,0x6DD93FCD,0x74C20E8C,
-        0xF35A1243,0xEA412302,0xC16C70C1,0xD8774180,0x9736D747,0x8E2DE606,0xA500B5C5,0xBC1B8484,
-        0x71418A1A,0x685ABB5B,0x4377E898,0x5A6CD9D9,0x152D4F1E,0x0C367E5F,0x271B2D9C,0x3E001CDD,
-        0xB9980012,0xA0833153,0x8BAE6290,0x92B553D1,0xDDF4C516,0xC4EFF457,0xEFC2A794,0xF6D996D5,
-        0xAE07BCE9,0xB71C8DA8,0x9C31DE6B,0x852AEF2A,0xCA6B79ED,0xD37048AC,0xF85D1B6F,0xE1462A2E,
-        0x66DE36E1,0x7FC507A0,0x54E85463,0x4DF36522,0x02B2F3E5,0x1BA9C2A4,0x30849167,0x299FA026,
-        0xE4C5AEB8,0xFDDE9FF9,0xD6F3CC3A,0xCFE8FD7B,0x80A96BBC,0x99B25AFD,0xB29F093E,0xAB84387F,
-        0x2C1C24B0,0x350715F1,0x1E2A4632,0x07317773,0x4870E1B4,0x516BD0F5,0x7A468336,0x635DB277,
-        0xCBFAD74E,0xD2E1E60F,0xF9CCB5CC,0xE0D7848D,0xAF96124A,0xB68D230B,0x9DA070C8,0x84BB4189,
-        0x03235D46,0x1A386C07,0x31153FC4,0x280E0E85,0x674F9842,0x7E54A903,0x5579FAC0,0x4C62CB81,
-        0x8138C51F,0x9823F45E,0xB30EA79D,0xAA1596DC,0xE554001B,0xFC4F315A,0xD7626299,0xCE7953D8,
-        0x49E14F17,0x50FA7E56,0x7BD72D95,0x62CC1CD4,0x2D8D8A13,0x3496BB52,0x1FBBE891,0x06A0D9D0,
-        0x5E7EF3EC,0x4765C2AD,0x6C48916E,0x7553A02F,0x3A1236E8,0x230907A9,0x0824546A,0x113F652B,
-        0x96A779E4,0x8FBC48A5,0xA4911B66,0xBD8A2A27,0xF2CBBCE0,0xEBD08DA1,0xC0FDDE62,0xD9E6EF23,
-        0x14BCE1BD,0x0DA7D0FC,0x268A833F,0x3F91B27E,0x70D024B9,0x69CB15F8,0x42E6463B,0x5BFD777A,
-        0xDC656BB5,0xC57E5AF4,0xEE530937,0xF7483876,0xB809AEB1,0xA1129FF0,0x8A3FCC33,0x9324FD72
-    },
+    {0x00000000, 0x191B3141, 0x32366282, 0x2B2D53C3, 0x646CC504, 0x7D77F445, 0x565AA786, 0x4F4196C7, 0xC8D98A08,
+     0xD1C2BB49, 0xFAEFE88A, 0xE3F4D9CB, 0xACB54F0C, 0xB5AE7E4D, 0x9E832D8E, 0x87981CCF, 0x4AC21251, 0x53D92310,
+     0x78F470D3, 0x61EF4192, 0x2EAED755, 0x37B5E614, 0x1C98B5D7, 0x05838496, 0x821B9859, 0x9B00A918, 0xB02DFADB,
+     0xA936CB9A, 0xE6775D5D, 0xFF6C6C1C, 0xD4413FDF, 0xCD5A0E9E, 0x958424A2, 0x8C9F15E3, 0xA7B24620, 0xBEA97761,
+     0xF1E8E1A6, 0xE8F3D0E7, 0xC3DE8324, 0xDAC5B265, 0x5D5DAEAA, 0x44469FEB, 0x6F6BCC28, 0x7670FD69, 0x39316BAE,
+     0x202A5AEF, 0x0B07092C, 0x121C386D, 0xDF4636F3, 0xC65D07B2, 0xED705471, 0xF46B6530, 0xBB2AF3F7, 0xA231C2B6,
+     0x891C9175, 0x9007A034, 0x179FBCFB, 0x0E848DBA, 0x25A9DE79, 0x3CB2EF38, 0x73F379FF, 0x6AE848BE, 0x41C51B7D,
+     0x58DE2A3C, 0xF0794F05, 0xE9627E44, 0xC24F2D87, 0xDB541CC6, 0x94158A01, 0x8D0EBB40, 0xA623E883, 0xBF38D9C2,
+     0x38A0C50D, 0x21BBF44C, 0x0A96A78F, 0x138D96CE, 0x5CCC0009, 0x45D73148, 0x6EFA628B, 0x77E153CA, 0xBABB5D54,
+     0xA3A06C15, 0x888D3FD6, 0x91960E97, 0xDED79850, 0xC7CCA911, 0xECE1FAD2, 0xF5FACB93, 0x7262D75C, 0x6B79E61D,
+     0x4054B5DE, 0x594F849F, 0x160E1258, 0x0F152319, 0x243870DA, 0x3D23419B, 0x65FD6BA7, 0x7CE65AE6, 0x57CB0925,
+     0x4ED03864, 0x0191AEA3, 0x188A9FE2, 0x33A7CC21, 0x2ABCFD60, 0xAD24E1AF, 0xB43FD0EE, 0x9F12832D, 0x8609B26C,
+     0xC94824AB, 0xD05315EA, 0xFB7E4629, 0xE2657768, 0x2F3F79F6, 0x362448B7, 0x1D091B74, 0x04122A35, 0x4B53BCF2,
+     0x52488DB3, 0x7965DE70, 0x607EEF31, 0xE7E6F3FE, 0xFEFDC2BF, 0xD5D0917C, 0xCCCBA03D, 0x838A36FA, 0x9A9107BB,
+     0xB1BC5478, 0xA8A76539, 0x3B83984B, 0x2298A90A, 0x09B5FAC9, 0x10AECB88, 0x5FEF5D4F, 0x46F46C0E, 0x6DD93FCD,
+     0x74C20E8C, 0xF35A1243, 0xEA412302, 0xC16C70C1, 0xD8774180, 0x9736D747, 0x8E2DE606, 0xA500B5C5, 0xBC1B8484,
+     0x71418A1A, 0x685ABB5B, 0x4377E898, 0x5A6CD9D9, 0x152D4F1E, 0x0C367E5F, 0x271B2D9C, 0x3E001CDD, 0xB9980012,
+     0xA0833153, 0x8BAE6290, 0x92B553D1, 0xDDF4C516, 0xC4EFF457, 0xEFC2A794, 0xF6D996D5, 0xAE07BCE9, 0xB71C8DA8,
+     0x9C31DE6B, 0x852AEF2A, 0xCA6B79ED, 0xD37048AC, 0xF85D1B6F, 0xE1462A2E, 0x66DE36E1, 0x7FC507A0, 0x54E85463,
+     0x4DF36522, 0x02B2F3E5, 0x1BA9C2A4, 0x30849167, 0x299FA026, 0xE4C5AEB8, 0xFDDE9FF9, 0xD6F3CC3A, 0xCFE8FD7B,
+     0x80A96BBC, 0x99B25AFD, 0xB29F093E, 0xAB84387F, 0x2C1C24B0, 0x350715F1, 0x1E2A4632, 0x07317773, 0x4870E1B4,
+     0x516BD0F5, 0x7A468336, 0x635DB277, 0xCBFAD74E, 0xD2E1E60F, 0xF9CCB5CC, 0xE0D7848D, 0xAF96124A, 0xB68D230B,
+     0x9DA070C8, 0x84BB4189, 0x03235D46, 0x1A386C07, 0x31153FC4, 0x280E0E85, 0x674F9842, 0x7E54A903, 0x5579FAC0,
+     0x4C62CB81, 0x8138C51F, 0x9823F45E, 0xB30EA79D, 0xAA1596DC, 0xE554001B, 0xFC4F315A, 0xD7626299, 0xCE7953D8,
+     0x49E14F17, 0x50FA7E56, 0x7BD72D95, 0x62CC1CD4, 0x2D8D8A13, 0x3496BB52, 0x1FBBE891, 0x06A0D9D0, 0x5E7EF3EC,
+     0x4765C2AD, 0x6C48916E, 0x7553A02F, 0x3A1236E8, 0x230907A9, 0x0824546A, 0x113F652B, 0x96A779E4, 0x8FBC48A5,
+     0xA4911B66, 0xBD8A2A27, 0xF2CBBCE0, 0xEBD08DA1, 0xC0FDDE62, 0xD9E6EF23, 0x14BCE1BD, 0x0DA7D0FC, 0x268A833F,
+     0x3F91B27E, 0x70D024B9, 0x69CB15F8, 0x42E6463B, 0x5BFD777A, 0xDC656BB5, 0xC57E5AF4, 0xEE530937, 0xF7483876,
+     0xB809AEB1, 0xA1129FF0, 0x8A3FCC33, 0x9324FD72},
 
-    {
-        0x00000000,0x01C26A37,0x0384D46E,0x0246BE59,0x0709A8DC,0x06CBC2EB,0x048D7CB2,0x054F1685,
-        0x0E1351B8,0x0FD13B8F,0x0D9785D6,0x0C55EFE1,0x091AF964,0x08D89353,0x0A9E2D0A,0x0B5C473D,
-        0x1C26A370,0x1DE4C947,0x1FA2771E,0x1E601D29,0x1B2F0BAC,0x1AED619B,0x18ABDFC2,0x1969B5F5,
-        0x1235F2C8,0x13F798FF,0x11B126A6,0x10734C91,0x153C5A14,0x14FE3023,0x16B88E7A,0x177AE44D,
-        0x384D46E0,0x398F2CD7,0x3BC9928E,0x3A0BF8B9,0x3F44EE3C,0x3E86840B,0x3CC03A52,0x3D025065,
-        0x365E1758,0x379C7D6F,0x35DAC336,0x3418A901,0x3157BF84,0x3095D5B3,0x32D36BEA,0x331101DD,
-        0x246BE590,0x25A98FA7,0x27EF31FE,0x262D5BC9,0x23624D4C,0x22A0277B,0x20E69922,0x2124F315,
-        0x2A78B428,0x2BBADE1F,0x29FC6046,0x283E0A71,0x2D711CF4,0x2CB376C3,0x2EF5C89A,0x2F37A2AD,
-        0x709A8DC0,0x7158E7F7,0x731E59AE,0x72DC3399,0x7793251C,0x76514F2B,0x7417F172,0x75D59B45,
-        0x7E89DC78,0x7F4BB64F,0x7D0D0816,0x7CCF6221,0x798074A4,0x78421E93,0x7A04A0CA,0x7BC6CAFD,
-        0x6CBC2EB0,0x6D7E4487,0x6F38FADE,0x6EFA90E9,0x6BB5866C,0x6A77EC5B,0x68315202,0x69F33835,
-        0x62AF7F08,0x636D153F,0x612BAB66,0x60E9C151,0x65A6D7D4,0x6464BDE3,0x662203BA,0x67E0698D,
-        0x48D7CB20,0x4915A117,0x4B531F4E,0x4A917579,0x4FDE63FC,0x4E1C09CB,0x4C5AB792,0x4D98DDA5,
-        0x46C49A98,0x4706F0AF,0x45404EF6,0x448224C1,0x41CD3244,0x400F5873,0x4249E62A,0x438B8C1D,
-        0x54F16850,0x55330267,0x5775BC3E,0x56B7D609,0x53F8C08C,0x523AAABB,0x507C14E2,0x51BE7ED5,
-        0x5AE239E8,0x5B2053DF,0x5966ED86,0x58A487B1,0x5DEB9134,0x5C29FB03,0x5E6F455A,0x5FAD2F6D,
-        0xE1351B80,0xE0F771B7,0xE2B1CFEE,0xE373A5D9,0xE63CB35C,0xE7FED96B,0xE5B86732,0xE47A0D05,
-        0xEF264A38,0xEEE4200F,0xECA29E56,0xED60F461,0xE82FE2E4,0xE9ED88D3,0xEBAB368A,0xEA695CBD,
-        0xFD13B8F0,0xFCD1D2C7,0xFE976C9E,0xFF5506A9,0xFA1A102C,0xFBD87A1B,0xF99EC442,0xF85CAE75,
-        0xF300E948,0xF2C2837F,0xF0843D26,0xF1465711,0xF4094194,0xF5CB2BA3,0xF78D95FA,0xF64FFFCD,
-        0xD9785D60,0xD8BA3757,0xDAFC890E,0xDB3EE339,0xDE71F5BC,0xDFB39F8B,0xDDF521D2,0xDC374BE5,
-        0xD76B0CD8,0xD6A966EF,0xD4EFD8B6,0xD52DB281,0xD062A404,0xD1A0CE33,0xD3E6706A,0xD2241A5D,
-        0xC55EFE10,0xC49C9427,0xC6DA2A7E,0xC7184049,0xC25756CC,0xC3953CFB,0xC1D382A2,0xC011E895,
-        0xCB4DAFA8,0xCA8FC59F,0xC8C97BC6,0xC90B11F1,0xCC440774,0xCD866D43,0xCFC0D31A,0xCE02B92D,
-        0x91AF9640,0x906DFC77,0x922B422E,0x93E92819,0x96A63E9C,0x976454AB,0x9522EAF2,0x94E080C5,
-        0x9FBCC7F8,0x9E7EADCF,0x9C381396,0x9DFA79A1,0x98B56F24,0x99770513,0x9B31BB4A,0x9AF3D17D,
-        0x8D893530,0x8C4B5F07,0x8E0DE15E,0x8FCF8B69,0x8A809DEC,0x8B42F7DB,0x89044982,0x88C623B5,
-        0x839A6488,0x82580EBF,0x801EB0E6,0x81DCDAD1,0x8493CC54,0x8551A663,0x8717183A,0x86D5720D,
-        0xA9E2D0A0,0xA820BA97,0xAA6604CE,0xABA46EF9,0xAEEB787C,0xAF29124B,0xAD6FAC12,0xACADC625,
-        0xA7F18118,0xA633EB2F,0xA4755576,0xA5B73F41,0xA0F829C4,0xA13A43F3,0xA37CFDAA,0xA2BE979D,
-        0xB5C473D0,0xB40619E7,0xB640A7BE,0xB782CD89,0xB2CDDB0C,0xB30FB13B,0xB1490F62,0xB08B6555,
-        0xBBD72268,0xBA15485F,0xB853F606,0xB9919C31,0xBCDE8AB4,0xBD1CE083,0xBF5A5EDA,0xBE9834ED
-    },
+    {0x00000000, 0x01C26A37, 0x0384D46E, 0x0246BE59, 0x0709A8DC, 0x06CBC2EB, 0x048D7CB2, 0x054F1685, 0x0E1351B8,
+     0x0FD13B8F, 0x0D9785D6, 0x0C55EFE1, 0x091AF964, 0x08D89353, 0x0A9E2D0A, 0x0B5C473D, 0x1C26A370, 0x1DE4C947,
+     0x1FA2771E, 0x1E601D29, 0x1B2F0BAC, 0x1AED619B, 0x18ABDFC2, 0x1969B5F5, 0x1235F2C8, 0x13F798FF, 0x11B126A6,
+     0x10734C91, 0x153C5A14, 0x14FE3023, 0x16B88E7A, 0x177AE44D, 0x384D46E0, 0x398F2CD7, 0x3BC9928E, 0x3A0BF8B9,
+     0x3F44EE3C, 0x3E86840B, 0x3CC03A52, 0x3D025065, 0x365E1758, 0x379C7D6F, 0x35DAC336, 0x3418A901, 0x3157BF84,
+     0x3095D5B3, 0x32D36BEA, 0x331101DD, 0x246BE590, 0x25A98FA7, 0x27EF31FE, 0x262D5BC9, 0x23624D4C, 0x22A0277B,
+     0x20E69922, 0x2124F315, 0x2A78B428, 0x2BBADE1F, 0x29FC6046, 0x283E0A71, 0x2D711CF4, 0x2CB376C3, 0x2EF5C89A,
+     0x2F37A2AD, 0x709A8DC0, 0x7158E7F7, 0x731E59AE, 0x72DC3399, 0x7793251C, 0x76514F2B, 0x7417F172, 0x75D59B45,
+     0x7E89DC78, 0x7F4BB64F, 0x7D0D0816, 0x7CCF6221, 0x798074A4, 0x78421E93, 0x7A04A0CA, 0x7BC6CAFD, 0x6CBC2EB0,
+     0x6D7E4487, 0x6F38FADE, 0x6EFA90E9, 0x6BB5866C, 0x6A77EC5B, 0x68315202, 0x69F33835, 0x62AF7F08, 0x636D153F,
+     0x612BAB66, 0x60E9C151, 0x65A6D7D4, 0x6464BDE3, 0x662203BA, 0x67E0698D, 0x48D7CB20, 0x4915A117, 0x4B531F4E,
+     0x4A917579, 0x4FDE63FC, 0x4E1C09CB, 0x4C5AB792, 0x4D98DDA5, 0x46C49A98, 0x4706F0AF, 0x45404EF6, 0x448224C1,
+     0x41CD3244, 0x400F5873, 0x4249E62A, 0x438B8C1D, 0x54F16850, 0x55330267, 0x5775BC3E, 0x56B7D609, 0x53F8C08C,
+     0x523AAABB, 0x507C14E2, 0x51BE7ED5, 0x5AE239E8, 0x5B2053DF, 0x5966ED86, 0x58A487B1, 0x5DEB9134, 0x5C29FB03,
+     0x5E6F455A, 0x5FAD2F6D, 0xE1351B80, 0xE0F771B7, 0xE2B1CFEE, 0xE373A5D9, 0xE63CB35C, 0xE7FED96B, 0xE5B86732,
+     0xE47A0D05, 0xEF264A38, 0xEEE4200F, 0xECA29E56, 0xED60F461, 0xE82FE2E4, 0xE9ED88D3, 0xEBAB368A, 0xEA695CBD,
+     0xFD13B8F0, 0xFCD1D2C7, 0xFE976C9E, 0xFF5506A9, 0xFA1A102C, 0xFBD87A1B, 0xF99EC442, 0xF85CAE75, 0xF300E948,
+     0xF2C2837F, 0xF0843D26, 0xF1465711, 0xF4094194, 0xF5CB2BA3, 0xF78D95FA, 0xF64FFFCD, 0xD9785D60, 0xD8BA3757,
+     0xDAFC890E, 0xDB3EE339, 0xDE71F5BC, 0xDFB39F8B, 0xDDF521D2, 0xDC374BE5, 0xD76B0CD8, 0xD6A966EF, 0xD4EFD8B6,
+     0xD52DB281, 0xD062A404, 0xD1A0CE33, 0xD3E6706A, 0xD2241A5D, 0xC55EFE10, 0xC49C9427, 0xC6DA2A7E, 0xC7184049,
+     0xC25756CC, 0xC3953CFB, 0xC1D382A2, 0xC011E895, 0xCB4DAFA8, 0xCA8FC59F, 0xC8C97BC6, 0xC90B11F1, 0xCC440774,
+     0xCD866D43, 0xCFC0D31A, 0xCE02B92D, 0x91AF9640, 0x906DFC77, 0x922B422E, 0x93E92819, 0x96A63E9C, 0x976454AB,
+     0x9522EAF2, 0x94E080C5, 0x9FBCC7F8, 0x9E7EADCF, 0x9C381396, 0x9DFA79A1, 0x98B56F24, 0x99770513, 0x9B31BB4A,
+     0x9AF3D17D, 0x8D893530, 0x8C4B5F07, 0x8E0DE15E, 0x8FCF8B69, 0x8A809DEC, 0x8B42F7DB, 0x89044982, 0x88C623B5,
+     0x839A6488, 0x82580EBF, 0x801EB0E6, 0x81DCDAD1, 0x8493CC54, 0x8551A663, 0x8717183A, 0x86D5720D, 0xA9E2D0A0,
+     0xA820BA97, 0xAA6604CE, 0xABA46EF9, 0xAEEB787C, 0xAF29124B, 0xAD6FAC12, 0xACADC625, 0xA7F18118, 0xA633EB2F,
+     0xA4755576, 0xA5B73F41, 0xA0F829C4, 0xA13A43F3, 0xA37CFDAA, 0xA2BE979D, 0xB5C473D0, 0xB40619E7, 0xB640A7BE,
+     0xB782CD89, 0xB2CDDB0C, 0xB30FB13B, 0xB1490F62, 0xB08B6555, 0xBBD72268, 0xBA15485F, 0xB853F606, 0xB9919C31,
+     0xBCDE8AB4, 0xBD1CE083, 0xBF5A5EDA, 0xBE9834ED},
 
-    {
-        0x00000000,0xB8BC6765,0xAA09C88B,0x12B5AFEE,0x8F629757,0x37DEF032,0x256B5FDC,0x9DD738B9,
-        0xC5B428EF,0x7D084F8A,0x6FBDE064,0xD7018701,0x4AD6BFB8,0xF26AD8DD,0xE0DF7733,0x58631056,
-        0x5019579F,0xE8A530FA,0xFA109F14,0x42ACF871,0xDF7BC0C8,0x67C7A7AD,0x75720843,0xCDCE6F26,
-        0x95AD7F70,0x2D111815,0x3FA4B7FB,0x8718D09E,0x1ACFE827,0xA2738F42,0xB0C620AC,0x087A47C9,
-        0xA032AF3E,0x188EC85B,0x0A3B67B5,0xB28700D0,0x2F503869,0x97EC5F0C,0x8559F0E2,0x3DE59787,
-        0x658687D1,0xDD3AE0B4,0xCF8F4F5A,0x7733283F,0xEAE41086,0x525877E3,0x40EDD80D,0xF851BF68,
-        0xF02BF8A1,0x48979FC4,0x5A22302A,0xE29E574F,0x7F496FF6,0xC7F50893,0xD540A77D,0x6DFCC018,
-        0x359FD04E,0x8D23B72B,0x9F9618C5,0x272A7FA0,0xBAFD4719,0x0241207C,0x10F48F92,0xA848E8F7,
-        0x9B14583D,0x23A83F58,0x311D90B6,0x89A1F7D3,0x1476CF6A,0xACCAA80F,0xBE7F07E1,0x06C36084,
-        0x5EA070D2,0xE61C17B7,0xF4A9B859,0x4C15DF3C,0xD1C2E785,0x697E80E0,0x7BCB2F0E,0xC377486B,
-        0xCB0D0FA2,0x73B168C7,0x6104C729,0xD9B8A04C,0x446F98F5,0xFCD3FF90,0xEE66507E,0x56DA371B,
-        0x0EB9274D,0xB6054028,0xA4B0EFC6,0x1C0C88A3,0x81DBB01A,0x3967D77F,0x2BD27891,0x936E1FF4,
-        0x3B26F703,0x839A9066,0x912F3F88,0x299358ED,0xB4446054,0x0CF80731,0x1E4DA8DF,0xA6F1CFBA,
-        0xFE92DFEC,0x462EB889,0x549B1767,0xEC277002,0x71F048BB,0xC94C2FDE,0xDBF98030,0x6345E755,
-        0x6B3FA09C,0xD383C7F9,0xC1366817,0x798A0F72,0xE45D37CB,0x5CE150AE,0x4E54FF40,0xF6E89825,
-        0xAE8B8873,0x1637EF16,0x048240F8,0xBC3E279D,0x21E91F24,0x99557841,0x8BE0D7AF,0x335CB0CA,
-        0xED59B63B,0x55E5D15E,0x47507EB0,0xFFEC19D5,0x623B216C,0xDA874609,0xC832E9E7,0x708E8E82,
-        0x28ED9ED4,0x9051F9B1,0x82E4565F,0x3A58313A,0xA78F0983,0x1F336EE6,0x0D86C108,0xB53AA66D,
-        0xBD40E1A4,0x05FC86C1,0x1749292F,0xAFF54E4A,0x322276F3,0x8A9E1196,0x982BBE78,0x2097D91D,
-        0x78F4C94B,0xC048AE2E,0xD2FD01C0,0x6A4166A5,0xF7965E1C,0x4F2A3979,0x5D9F9697,0xE523F1F2,
-        0x4D6B1905,0xF5D77E60,0xE762D18E,0x5FDEB6EB,0xC2098E52,0x7AB5E937,0x680046D9,0xD0BC21BC,
-        0x88DF31EA,0x3063568F,0x22D6F961,0x9A6A9E04,0x07BDA6BD,0xBF01C1D8,0xADB46E36,0x15080953,
-        0x1D724E9A,0xA5CE29FF,0xB77B8611,0x0FC7E174,0x9210D9CD,0x2AACBEA8,0x38191146,0x80A57623,
-        0xD8C66675,0x607A0110,0x72CFAEFE,0xCA73C99B,0x57A4F122,0xEF189647,0xFDAD39A9,0x45115ECC,
-        0x764DEE06,0xCEF18963,0xDC44268D,0x64F841E8,0xF92F7951,0x41931E34,0x5326B1DA,0xEB9AD6BF,
-        0xB3F9C6E9,0x0B45A18C,0x19F00E62,0xA14C6907,0x3C9B51BE,0x842736DB,0x96929935,0x2E2EFE50,
-        0x2654B999,0x9EE8DEFC,0x8C5D7112,0x34E11677,0xA9362ECE,0x118A49AB,0x033FE645,0xBB838120,
-        0xE3E09176,0x5B5CF613,0x49E959FD,0xF1553E98,0x6C820621,0xD43E6144,0xC68BCEAA,0x7E37A9CF,
-        0xD67F4138,0x6EC3265D,0x7C7689B3,0xC4CAEED6,0x591DD66F,0xE1A1B10A,0xF3141EE4,0x4BA87981,
-        0x13CB69D7,0xAB770EB2,0xB9C2A15C,0x017EC639,0x9CA9FE80,0x241599E5,0x36A0360B,0x8E1C516E,
-        0x866616A7,0x3EDA71C2,0x2C6FDE2C,0x94D3B949,0x090481F0,0xB1B8E695,0xA30D497B,0x1BB12E1E,
-        0x43D23E48,0xFB6E592D,0xE9DBF6C3,0x516791A6,0xCCB0A91F,0x740CCE7A,0x66B96194,0xDE0506F1
-    },
+    {0x00000000, 0xB8BC6765, 0xAA09C88B, 0x12B5AFEE, 0x8F629757, 0x37DEF032, 0x256B5FDC, 0x9DD738B9, 0xC5B428EF,
+     0x7D084F8A, 0x6FBDE064, 0xD7018701, 0x4AD6BFB8, 0xF26AD8DD, 0xE0DF7733, 0x58631056, 0x5019579F, 0xE8A530FA,
+     0xFA109F14, 0x42ACF871, 0xDF7BC0C8, 0x67C7A7AD, 0x75720843, 0xCDCE6F26, 0x95AD7F70, 0x2D111815, 0x3FA4B7FB,
+     0x8718D09E, 0x1ACFE827, 0xA2738F42, 0xB0C620AC, 0x087A47C9, 0xA032AF3E, 0x188EC85B, 0x0A3B67B5, 0xB28700D0,
+     0x2F503869, 0x97EC5F0C, 0x8559F0E2, 0x3DE59787, 0x658687D1, 0xDD3AE0B4, 0xCF8F4F5A, 0x7733283F, 0xEAE41086,
+     0x525877E3, 0x40EDD80D, 0xF851BF68, 0xF02BF8A1, 0x48979FC4, 0x5A22302A, 0xE29E574F, 0x7F496FF6, 0xC7F50893,
+     0xD540A77D, 0x6DFCC018, 0x359FD04E, 0x8D23B72B, 0x9F9618C5, 0x272A7FA0, 0xBAFD4719, 0x0241207C, 0x10F48F92,
+     0xA848E8F7, 0x9B14583D, 0x23A83F58, 0x311D90B6, 0x89A1F7D3, 0x1476CF6A, 0xACCAA80F, 0xBE7F07E1, 0x06C36084,
+     0x5EA070D2, 0xE61C17B7, 0xF4A9B859, 0x4C15DF3C, 0xD1C2E785, 0x697E80E0, 0x7BCB2F0E, 0xC377486B, 0xCB0D0FA2,
+     0x73B168C7, 0x6104C729, 0xD9B8A04C, 0x446F98F5, 0xFCD3FF90, 0xEE66507E, 0x56DA371B, 0x0EB9274D, 0xB6054028,
+     0xA4B0EFC6, 0x1C0C88A3, 0x81DBB01A, 0x3967D77F, 0x2BD27891, 0x936E1FF4, 0x3B26F703, 0x839A9066, 0x912F3F88,
+     0x299358ED, 0xB4446054, 0x0CF80731, 0x1E4DA8DF, 0xA6F1CFBA, 0xFE92DFEC, 0x462EB889, 0x549B1767, 0xEC277002,
+     0x71F048BB, 0xC94C2FDE, 0xDBF98030, 0x6345E755, 0x6B3FA09C, 0xD383C7F9, 0xC1366817, 0x798A0F72, 0xE45D37CB,
+     0x5CE150AE, 0x4E54FF40, 0xF6E89825, 0xAE8B8873, 0x1637EF16, 0x048240F8, 0xBC3E279D, 0x21E91F24, 0x99557841,
+     0x8BE0D7AF, 0x335CB0CA, 0xED59B63B, 0x55E5D15E, 0x47507EB0, 0xFFEC19D5, 0x623B216C, 0xDA874609, 0xC832E9E7,
+     0x708E8E82, 0x28ED9ED4, 0x9051F9B1, 0x82E4565F, 0x3A58313A, 0xA78F0983, 0x1F336EE6, 0x0D86C108, 0xB53AA66D,
+     0xBD40E1A4, 0x05FC86C1, 0x1749292F, 0xAFF54E4A, 0x322276F3, 0x8A9E1196, 0x982BBE78, 0x2097D91D, 0x78F4C94B,
+     0xC048AE2E, 0xD2FD01C0, 0x6A4166A5, 0xF7965E1C, 0x4F2A3979, 0x5D9F9697, 0xE523F1F2, 0x4D6B1905, 0xF5D77E60,
+     0xE762D18E, 0x5FDEB6EB, 0xC2098E52, 0x7AB5E937, 0x680046D9, 0xD0BC21BC, 0x88DF31EA, 0x3063568F, 0x22D6F961,
+     0x9A6A9E04, 0x07BDA6BD, 0xBF01C1D8, 0xADB46E36, 0x15080953, 0x1D724E9A, 0xA5CE29FF, 0xB77B8611, 0x0FC7E174,
+     0x9210D9CD, 0x2AACBEA8, 0x38191146, 0x80A57623, 0xD8C66675, 0x607A0110, 0x72CFAEFE, 0xCA73C99B, 0x57A4F122,
+     0xEF189647, 0xFDAD39A9, 0x45115ECC, 0x764DEE06, 0xCEF18963, 0xDC44268D, 0x64F841E8, 0xF92F7951, 0x41931E34,
+     0x5326B1DA, 0xEB9AD6BF, 0xB3F9C6E9, 0x0B45A18C, 0x19F00E62, 0xA14C6907, 0x3C9B51BE, 0x842736DB, 0x96929935,
+     0x2E2EFE50, 0x2654B999, 0x9EE8DEFC, 0x8C5D7112, 0x34E11677, 0xA9362ECE, 0x118A49AB, 0x033FE645, 0xBB838120,
+     0xE3E09176, 0x5B5CF613, 0x49E959FD, 0xF1553E98, 0x6C820621, 0xD43E6144, 0xC68BCEAA, 0x7E37A9CF, 0xD67F4138,
+     0x6EC3265D, 0x7C7689B3, 0xC4CAEED6, 0x591DD66F, 0xE1A1B10A, 0xF3141EE4, 0x4BA87981, 0x13CB69D7, 0xAB770EB2,
+     0xB9C2A15C, 0x017EC639, 0x9CA9FE80, 0x241599E5, 0x36A0360B, 0x8E1C516E, 0x866616A7, 0x3EDA71C2, 0x2C6FDE2C,
+     0x94D3B949, 0x090481F0, 0xB1B8E695, 0xA30D497B, 0x1BB12E1E, 0x43D23E48, 0xFB6E592D, 0xE9DBF6C3, 0x516791A6,
+     0xCCB0A91F, 0x740CCE7A, 0x66B96194, 0xDE0506F1},
 
-    {
-        0x00000000,0x3D6029B0,0x7AC05360,0x47A07AD0,0xF580A6C0,0xC8E08F70,0x8F40F5A0,0xB220DC10,
-        0x30704BC1,0x0D106271,0x4AB018A1,0x77D03111,0xC5F0ED01,0xF890C4B1,0xBF30BE61,0x825097D1,
-        0x60E09782,0x5D80BE32,0x1A20C4E2,0x2740ED52,0x95603142,0xA80018F2,0xEFA06222,0xD2C04B92,
-        0x5090DC43,0x6DF0F5F3,0x2A508F23,0x1730A693,0xA5107A83,0x98705333,0xDFD029E3,0xE2B00053,
-        0xC1C12F04,0xFCA106B4,0xBB017C64,0x866155D4,0x344189C4,0x0921A074,0x4E81DAA4,0x73E1F314,
-        0xF1B164C5,0xCCD14D75,0x8B7137A5,0xB6111E15,0x0431C205,0x3951EBB5,0x7EF19165,0x4391B8D5,
-        0xA121B886,0x9C419136,0xDBE1EBE6,0xE681C256,0x54A11E46,0x69C137F6,0x2E614D26,0x13016496,
-        0x9151F347,0xAC31DAF7,0xEB91A027,0xD6F18997,0x64D15587,0x59B17C37,0x1E1106E7,0x23712F57,
-        0x58F35849,0x659371F9,0x22330B29,0x1F532299,0xAD73FE89,0x9013D739,0xD7B3ADE9,0xEAD38459,
-        0x68831388,0x55E33A38,0x124340E8,0x2F236958,0x9D03B548,0xA0639CF8,0xE7C3E628,0xDAA3CF98,
-        0x3813CFCB,0x0573E67B,0x42D39CAB,0x7FB3B51B,0xCD93690B,0xF0F340BB,0xB7533A6B,0x8A3313DB,
-        0x0863840A,0x3503ADBA,0x72A3D76A,0x4FC3FEDA,0xFDE322CA,0xC0830B7A,0x872371AA,0xBA43581A,
-        0x9932774D,0xA4525EFD,0xE3F2242D,0xDE920D9D,0x6CB2D18D,0x51D2F83D,0x167282ED,0x2B12AB5D,
-        0xA9423C8C,0x9422153C,0xD3826FEC,0xEEE2465C,0x5CC29A4C,0x61A2B3FC,0x2602C92C,0x1B62E09C,
-        0xF9D2E0CF,0xC4B2C97F,0x8312B3AF,0xBE729A1F,0x0C52460F,0x31326FBF,0x7692156F,0x4BF23CDF,
-        0xC9A2AB0E,0xF4C282BE,0xB362F86E,0x8E02D1DE,0x3C220DCE,0x0142247E,0x46E25EAE,0x7B82771E,
-        0xB1E6B092,0x8C869922,0xCB26E3F2,0xF646CA42,0x44661652,0x79063FE2,0x3EA64532,0x03C66C82,
-        0x8196FB53,0xBCF6D2E3,0xFB56A833,0xC6368183,0x74165D93,0x49767423,0x0ED60EF3,0x33B62743,
-        0xD1062710,0xEC660EA0,0xABC67470,0x96A65DC0,0x248681D0,0x19E6A860,0x5E46D2B0,0x6326FB00,
-        0xE1766CD1,0xDC164561,0x9BB63FB1,0xA6D61601,0x14F6CA11,0x2996E3A1,0x6E369971,0x5356B0C1,
-        0x70279F96,0x4D47B626,0x0AE7CCF6,0x3787E546,0x85A73956,0xB8C710E6,0xFF676A36,0xC2074386,
-        0x4057D457,0x7D37FDE7,0x3A978737,0x07F7AE87,0xB5D77297,0x88B75B27,0xCF1721F7,0xF2770847,
-        0x10C70814,0x2DA721A4,0x6A075B74,0x576772C4,0xE547AED4,0xD8278764,0x9F87FDB4,0xA2E7D404,
-        0x20B743D5,0x1DD76A65,0x5A7710B5,0x67173905,0xD537E515,0xE857CCA5,0xAFF7B675,0x92979FC5,
-        0xE915E8DB,0xD475C16B,0x93D5BBBB,0xAEB5920B,0x1C954E1B,0x21F567AB,0x66551D7B,0x5B3534CB,
-        0xD965A31A,0xE4058AAA,0xA3A5F07A,0x9EC5D9CA,0x2CE505DA,0x11852C6A,0x562556BA,0x6B457F0A,
-        0x89F57F59,0xB49556E9,0xF3352C39,0xCE550589,0x7C75D999,0x4115F029,0x06B58AF9,0x3BD5A349,
-        0xB9853498,0x84E51D28,0xC34567F8,0xFE254E48,0x4C059258,0x7165BBE8,0x36C5C138,0x0BA5E888,
-        0x28D4C7DF,0x15B4EE6F,0x521494BF,0x6F74BD0F,0xDD54611F,0xE03448AF,0xA794327F,0x9AF41BCF,
-        0x18A48C1E,0x25C4A5AE,0x6264DF7E,0x5F04F6CE,0xED242ADE,0xD044036E,0x97E479BE,0xAA84500E,
-        0x4834505D,0x755479ED,0x32F4033D,0x0F942A8D,0xBDB4F69D,0x80D4DF2D,0xC774A5FD,0xFA148C4D,
-        0x78441B9C,0x4524322C,0x028448FC,0x3FE4614C,0x8DC4BD5C,0xB0A494EC,0xF704EE3C,0xCA64C78C
-    },
+    {0x00000000, 0x3D6029B0, 0x7AC05360, 0x47A07AD0, 0xF580A6C0, 0xC8E08F70, 0x8F40F5A0, 0xB220DC10, 0x30704BC1,
+     0x0D106271, 0x4AB018A1, 0x77D03111, 0xC5F0ED01, 0xF890C4B1, 0xBF30BE61, 0x825097D1, 0x60E09782, 0x5D80BE32,
+     0x1A20C4E2, 0x2740ED52, 0x95603142, 0xA80018F2, 0xEFA06222, 0xD2C04B92, 0x5090DC43, 0x6DF0F5F3, 0x2A508F23,
+     0x1730A693, 0xA5107A83, 0x98705333, 0xDFD029E3, 0xE2B00053, 0xC1C12F04, 0xFCA106B4, 0xBB017C64, 0x866155D4,
+     0x344189C4, 0x0921A074, 0x4E81DAA4, 0x73E1F314, 0xF1B164C5, 0xCCD14D75, 0x8B7137A5, 0xB6111E15, 0x0431C205,
+     0x3951EBB5, 0x7EF19165, 0x4391B8D5, 0xA121B886, 0x9C419136, 0xDBE1EBE6, 0xE681C256, 0x54A11E46, 0x69C137F6,
+     0x2E614D26, 0x13016496, 0x9151F347, 0xAC31DAF7, 0xEB91A027, 0xD6F18997, 0x64D15587, 0x59B17C37, 0x1E1106E7,
+     0x23712F57, 0x58F35849, 0x659371F9, 0x22330B29, 0x1F532299, 0xAD73FE89, 0x9013D739, 0xD7B3ADE9, 0xEAD38459,
+     0x68831388, 0x55E33A38, 0x124340E8, 0x2F236958, 0x9D03B548, 0xA0639CF8, 0xE7C3E628, 0xDAA3CF98, 0x3813CFCB,
+     0x0573E67B, 0x42D39CAB, 0x7FB3B51B, 0xCD93690B, 0xF0F340BB, 0xB7533A6B, 0x8A3313DB, 0x0863840A, 0x3503ADBA,
+     0x72A3D76A, 0x4FC3FEDA, 0xFDE322CA, 0xC0830B7A, 0x872371AA, 0xBA43581A, 0x9932774D, 0xA4525EFD, 0xE3F2242D,
+     0xDE920D9D, 0x6CB2D18D, 0x51D2F83D, 0x167282ED, 0x2B12AB5D, 0xA9423C8C, 0x9422153C, 0xD3826FEC, 0xEEE2465C,
+     0x5CC29A4C, 0x61A2B3FC, 0x2602C92C, 0x1B62E09C, 0xF9D2E0CF, 0xC4B2C97F, 0x8312B3AF, 0xBE729A1F, 0x0C52460F,
+     0x31326FBF, 0x7692156F, 0x4BF23CDF, 0xC9A2AB0E, 0xF4C282BE, 0xB362F86E, 0x8E02D1DE, 0x3C220DCE, 0x0142247E,
+     0x46E25EAE, 0x7B82771E, 0xB1E6B092, 0x8C869922, 0xCB26E3F2, 0xF646CA42, 0x44661652, 0x79063FE2, 0x3EA64532,
+     0x03C66C82, 0x8196FB53, 0xBCF6D2E3, 0xFB56A833, 0xC6368183, 0x74165D93, 0x49767423, 0x0ED60EF3, 0x33B62743,
+     0xD1062710, 0xEC660EA0, 0xABC67470, 0x96A65DC0, 0x248681D0, 0x19E6A860, 0x5E46D2B0, 0x6326FB00, 0xE1766CD1,
+     0xDC164561, 0x9BB63FB1, 0xA6D61601, 0x14F6CA11, 0x2996E3A1, 0x6E369971, 0x5356B0C1, 0x70279F96, 0x4D47B626,
+     0x0AE7CCF6, 0x3787E546, 0x85A73956, 0xB8C710E6, 0xFF676A36, 0xC2074386, 0x4057D457, 0x7D37FDE7, 0x3A978737,
+     0x07F7AE87, 0xB5D77297, 0x88B75B27, 0xCF1721F7, 0xF2770847, 0x10C70814, 0x2DA721A4, 0x6A075B74, 0x576772C4,
+     0xE547AED4, 0xD8278764, 0x9F87FDB4, 0xA2E7D404, 0x20B743D5, 0x1DD76A65, 0x5A7710B5, 0x67173905, 0xD537E515,
+     0xE857CCA5, 0xAFF7B675, 0x92979FC5, 0xE915E8DB, 0xD475C16B, 0x93D5BBBB, 0xAEB5920B, 0x1C954E1B, 0x21F567AB,
+     0x66551D7B, 0x5B3534CB, 0xD965A31A, 0xE4058AAA, 0xA3A5F07A, 0x9EC5D9CA, 0x2CE505DA, 0x11852C6A, 0x562556BA,
+     0x6B457F0A, 0x89F57F59, 0xB49556E9, 0xF3352C39, 0xCE550589, 0x7C75D999, 0x4115F029, 0x06B58AF9, 0x3BD5A349,
+     0xB9853498, 0x84E51D28, 0xC34567F8, 0xFE254E48, 0x4C059258, 0x7165BBE8, 0x36C5C138, 0x0BA5E888, 0x28D4C7DF,
+     0x15B4EE6F, 0x521494BF, 0x6F74BD0F, 0xDD54611F, 0xE03448AF, 0xA794327F, 0x9AF41BCF, 0x18A48C1E, 0x25C4A5AE,
+     0x6264DF7E, 0x5F04F6CE, 0xED242ADE, 0xD044036E, 0x97E479BE, 0xAA84500E, 0x4834505D, 0x755479ED, 0x32F4033D,
+     0x0F942A8D, 0xBDB4F69D, 0x80D4DF2D, 0xC774A5FD, 0xFA148C4D, 0x78441B9C, 0x4524322C, 0x028448FC, 0x3FE4614C,
+     0x8DC4BD5C, 0xB0A494EC, 0xF704EE3C, 0xCA64C78C},
 
-    {
-        0x00000000,0xCB5CD3A5,0x4DC8A10B,0x869472AE,0x9B914216,0x50CD91B3,0xD659E31D,0x1D0530B8,
-        0xEC53826D,0x270F51C8,0xA19B2366,0x6AC7F0C3,0x77C2C07B,0xBC9E13DE,0x3A0A6170,0xF156B2D5,
-        0x03D6029B,0xC88AD13E,0x4E1EA390,0x85427035,0x9847408D,0x531B9328,0xD58FE186,0x1ED33223,
-        0xEF8580F6,0x24D95353,0xA24D21FD,0x6911F258,0x7414C2E0,0xBF481145,0x39DC63EB,0xF280B04E,
-        0x07AC0536,0xCCF0D693,0x4A64A43D,0x81387798,0x9C3D4720,0x57619485,0xD1F5E62B,0x1AA9358E,
-        0xEBFF875B,0x20A354FE,0xA6372650,0x6D6BF5F5,0x706EC54D,0xBB3216E8,0x3DA66446,0xF6FAB7E3,
-        0x047A07AD,0xCF26D408,0x49B2A6A6,0x82EE7503,0x9FEB45BB,0x54B7961E,0xD223E4B0,0x197F3715,
-        0xE82985C0,0x23755665,0xA5E124CB,0x6EBDF76E,0x73B8C7D6,0xB8E41473,0x3E7066DD,0xF52CB578,
-        0x0F580A6C,0xC404D9C9,0x4290AB67,0x89CC78C2,0x94C9487A,0x5F959BDF,0xD901E971,0x125D3AD4,
-        0xE30B8801,0x28575BA4,0xAEC3290A,0x659FFAAF,0x789ACA17,0xB3C619B2,0x35526B1C,0xFE0EB8B9,
-        0x0C8E08F7,0xC7D2DB52,0x4146A9FC,0x8A1A7A59,0x971F4AE1,0x5C439944,0xDAD7EBEA,0x118B384F,
-        0xE0DD8A9A,0x2B81593F,0xAD152B91,0x6649F834,0x7B4CC88C,0xB0101B29,0x36846987,0xFDD8BA22,
-        0x08F40F5A,0xC3A8DCFF,0x453CAE51,0x8E607DF4,0x93654D4C,0x58399EE9,0xDEADEC47,0x15F13FE2,
-        0xE4A78D37,0x2FFB5E92,0xA96F2C3C,0x6233FF99,0x7F36CF21,0xB46A1C84,0x32FE6E2A,0xF9A2BD8F,
-        0x0B220DC1,0xC07EDE64,0x46EAACCA,0x8DB67F6F,0x90B34FD7,0x5BEF9C72,0xDD7BEEDC,0x16273D79,
-        0xE7718FAC,0x2C2D5C09,0xAAB92EA7,0x61E5FD02,0x7CE0CDBA,0xB7BC1E1F,0x31286CB1,0xFA74BF14,
-        0x1EB014D8,0xD5ECC77D,0x5378B5D3,0x98246676,0x852156CE,0x4E7D856B,0xC8E9F7C5,0x03B52460,
-        0xF2E396B5,0x39BF4510,0xBF2B37BE,0x7477E41B,0x6972D4A3,0xA22E0706,0x24BA75A8,0xEFE6A60D,
-        0x1D661643,0xD63AC5E6,0x50AEB748,0x9BF264ED,0x86F75455,0x4DAB87F0,0xCB3FF55E,0x006326FB,
-        0xF135942E,0x3A69478B,0xBCFD3525,0x77A1E680,0x6AA4D638,0xA1F8059D,0x276C7733,0xEC30A496,
-        0x191C11EE,0xD240C24B,0x54D4B0E5,0x9F886340,0x828D53F8,0x49D1805D,0xCF45F2F3,0x04192156,
-        0xF54F9383,0x3E134026,0xB8873288,0x73DBE12D,0x6EDED195,0xA5820230,0x2316709E,0xE84AA33B,
-        0x1ACA1375,0xD196C0D0,0x5702B27E,0x9C5E61DB,0x815B5163,0x4A0782C6,0xCC93F068,0x07CF23CD,
-        0xF6999118,0x3DC542BD,0xBB513013,0x700DE3B6,0x6D08D30E,0xA65400AB,0x20C07205,0xEB9CA1A0,
-        0x11E81EB4,0xDAB4CD11,0x5C20BFBF,0x977C6C1A,0x8A795CA2,0x41258F07,0xC7B1FDA9,0x0CED2E0C,
-        0xFDBB9CD9,0x36E74F7C,0xB0733DD2,0x7B2FEE77,0x662ADECF,0xAD760D6A,0x2BE27FC4,0xE0BEAC61,
-        0x123E1C2F,0xD962CF8A,0x5FF6BD24,0x94AA6E81,0x89AF5E39,0x42F38D9C,0xC467FF32,0x0F3B2C97,
-        0xFE6D9E42,0x35314DE7,0xB3A53F49,0x78F9ECEC,0x65FCDC54,0xAEA00FF1,0x28347D5F,0xE368AEFA,
-        0x16441B82,0xDD18C827,0x5B8CBA89,0x90D0692C,0x8DD55994,0x46898A31,0xC01DF89F,0x0B412B3A,
-        0xFA1799EF,0x314B4A4A,0xB7DF38E4,0x7C83EB41,0x6186DBF9,0xAADA085C,0x2C4E7AF2,0xE712A957,
-        0x15921919,0xDECECABC,0x585AB812,0x93066BB7,0x8E035B0F,0x455F88AA,0xC3CBFA04,0x089729A1,
-        0xF9C19B74,0x329D48D1,0xB4093A7F,0x7F55E9DA,0x6250D962,0xA90C0AC7,0x2F987869,0xE4C4ABCC
-    },
+    {0x00000000, 0xCB5CD3A5, 0x4DC8A10B, 0x869472AE, 0x9B914216, 0x50CD91B3, 0xD659E31D, 0x1D0530B8, 0xEC53826D,
+     0x270F51C8, 0xA19B2366, 0x6AC7F0C3, 0x77C2C07B, 0xBC9E13DE, 0x3A0A6170, 0xF156B2D5, 0x03D6029B, 0xC88AD13E,
+     0x4E1EA390, 0x85427035, 0x9847408D, 0x531B9328, 0xD58FE186, 0x1ED33223, 0xEF8580F6, 0x24D95353, 0xA24D21FD,
+     0x6911F258, 0x7414C2E0, 0xBF481145, 0x39DC63EB, 0xF280B04E, 0x07AC0536, 0xCCF0D693, 0x4A64A43D, 0x81387798,
+     0x9C3D4720, 0x57619485, 0xD1F5E62B, 0x1AA9358E, 0xEBFF875B, 0x20A354FE, 0xA6372650, 0x6D6BF5F5, 0x706EC54D,
+     0xBB3216E8, 0x3DA66446, 0xF6FAB7E3, 0x047A07AD, 0xCF26D408, 0x49B2A6A6, 0x82EE7503, 0x9FEB45BB, 0x54B7961E,
+     0xD223E4B0, 0x197F3715, 0xE82985C0, 0x23755665, 0xA5E124CB, 0x6EBDF76E, 0x73B8C7D6, 0xB8E41473, 0x3E7066DD,
+     0xF52CB578, 0x0F580A6C, 0xC404D9C9, 0x4290AB67, 0x89CC78C2, 0x94C9487A, 0x5F959BDF, 0xD901E971, 0x125D3AD4,
+     0xE30B8801, 0x28575BA4, 0xAEC3290A, 0x659FFAAF, 0x789ACA17, 0xB3C619B2, 0x35526B1C, 0xFE0EB8B9, 0x0C8E08F7,
+     0xC7D2DB52, 0x4146A9FC, 0x8A1A7A59, 0x971F4AE1, 0x5C439944, 0xDAD7EBEA, 0x118B384F, 0xE0DD8A9A, 0x2B81593F,
+     0xAD152B91, 0x6649F834, 0x7B4CC88C, 0xB0101B29, 0x36846987, 0xFDD8BA22, 0x08F40F5A, 0xC3A8DCFF, 0x453CAE51,
+     0x8E607DF4, 0x93654D4C, 0x58399EE9, 0xDEADEC47, 0x15F13FE2, 0xE4A78D37, 0x2FFB5E92, 0xA96F2C3C, 0x6233FF99,
+     0x7F36CF21, 0xB46A1C84, 0x32FE6E2A, 0xF9A2BD8F, 0x0B220DC1, 0xC07EDE64, 0x46EAACCA, 0x8DB67F6F, 0x90B34FD7,
+     0x5BEF9C72, 0xDD7BEEDC, 0x16273D79, 0xE7718FAC, 0x2C2D5C09, 0xAAB92EA7, 0x61E5FD02, 0x7CE0CDBA, 0xB7BC1E1F,
+     0x31286CB1, 0xFA74BF14, 0x1EB014D8, 0xD5ECC77D, 0x5378B5D3, 0x98246676, 0x852156CE, 0x4E7D856B, 0xC8E9F7C5,
+     0x03B52460, 0xF2E396B5, 0x39BF4510, 0xBF2B37BE, 0x7477E41B, 0x6972D4A3, 0xA22E0706, 0x24BA75A8, 0xEFE6A60D,
+     0x1D661643, 0xD63AC5E6, 0x50AEB748, 0x9BF264ED, 0x86F75455, 0x4DAB87F0, 0xCB3FF55E, 0x006326FB, 0xF135942E,
+     0x3A69478B, 0xBCFD3525, 0x77A1E680, 0x6AA4D638, 0xA1F8059D, 0x276C7733, 0xEC30A496, 0x191C11EE, 0xD240C24B,
+     0x54D4B0E5, 0x9F886340, 0x828D53F8, 0x49D1805D, 0xCF45F2F3, 0x04192156, 0xF54F9383, 0x3E134026, 0xB8873288,
+     0x73DBE12D, 0x6EDED195, 0xA5820230, 0x2316709E, 0xE84AA33B, 0x1ACA1375, 0xD196C0D0, 0x5702B27E, 0x9C5E61DB,
+     0x815B5163, 0x4A0782C6, 0xCC93F068, 0x07CF23CD, 0xF6999118, 0x3DC542BD, 0xBB513013, 0x700DE3B6, 0x6D08D30E,
+     0xA65400AB, 0x20C07205, 0xEB9CA1A0, 0x11E81EB4, 0xDAB4CD11, 0x5C20BFBF, 0x977C6C1A, 0x8A795CA2, 0x41258F07,
+     0xC7B1FDA9, 0x0CED2E0C, 0xFDBB9CD9, 0x36E74F7C, 0xB0733DD2, 0x7B2FEE77, 0x662ADECF, 0xAD760D6A, 0x2BE27FC4,
+     0xE0BEAC61, 0x123E1C2F, 0xD962CF8A, 0x5FF6BD24, 0x94AA6E81, 0x89AF5E39, 0x42F38D9C, 0xC467FF32, 0x0F3B2C97,
+     0xFE6D9E42, 0x35314DE7, 0xB3A53F49, 0x78F9ECEC, 0x65FCDC54, 0xAEA00FF1, 0x28347D5F, 0xE368AEFA, 0x16441B82,
+     0xDD18C827, 0x5B8CBA89, 0x90D0692C, 0x8DD55994, 0x46898A31, 0xC01DF89F, 0x0B412B3A, 0xFA1799EF, 0x314B4A4A,
+     0xB7DF38E4, 0x7C83EB41, 0x6186DBF9, 0xAADA085C, 0x2C4E7AF2, 0xE712A957, 0x15921919, 0xDECECABC, 0x585AB812,
+     0x93066BB7, 0x8E035B0F, 0x455F88AA, 0xC3CBFA04, 0x089729A1, 0xF9C19B74, 0x329D48D1, 0xB4093A7F, 0x7F55E9DA,
+     0x6250D962, 0xA90C0AC7, 0x2F987869, 0xE4C4ABCC},
 
-    {
-        0x00000000,0xA6770BB4,0x979F1129,0x31E81A9D,0xF44F2413,0x52382FA7,0x63D0353A,0xC5A73E8E,
-        0x33EF4E67,0x959845D3,0xA4705F4E,0x020754FA,0xC7A06A74,0x61D761C0,0x503F7B5D,0xF64870E9,
-        0x67DE9CCE,0xC1A9977A,0xF0418DE7,0x56368653,0x9391B8DD,0x35E6B369,0x040EA9F4,0xA279A240,
-        0x5431D2A9,0xF246D91D,0xC3AEC380,0x65D9C834,0xA07EF6BA,0x0609FD0E,0x37E1E793,0x9196EC27,
-        0xCFBD399C,0x69CA3228,0x582228B5,0xFE552301,0x3BF21D8F,0x9D85163B,0xAC6D0CA6,0x0A1A0712,
-        0xFC5277FB,0x5A257C4F,0x6BCD66D2,0xCDBA6D66,0x081D53E8,0xAE6A585C,0x9F8242C1,0x39F54975,
-        0xA863A552,0x0E14AEE6,0x3FFCB47B,0x998BBFCF,0x5C2C8141,0xFA5B8AF5,0xCBB39068,0x6DC49BDC,
-        0x9B8CEB35,0x3DFBE081,0x0C13FA1C,0xAA64F1A8,0x6FC3CF26,0xC9B4C492,0xF85CDE0F,0x5E2BD5BB,
-        0x440B7579,0xE27C7ECD,0xD3946450,0x75E36FE4,0xB044516A,0x16335ADE,0x27DB4043,0x81AC4BF7,
-        0x77E43B1E,0xD19330AA,0xE07B2A37,0x460C2183,0x83AB1F0D,0x25DC14B9,0x14340E24,0xB2430590,
-        0x23D5E9B7,0x85A2E203,0xB44AF89E,0x123DF32A,0xD79ACDA4,0x71EDC610,0x4005DC8D,0xE672D739,
-        0x103AA7D0,0xB64DAC64,0x87A5B6F9,0x21D2BD4D,0xE47583C3,0x42028877,0x73EA92EA,0xD59D995E,
-        0x8BB64CE5,0x2DC14751,0x1C295DCC,0xBA5E5678,0x7FF968F6,0xD98E6342,0xE86679DF,0x4E11726B,
-        0xB8590282,0x1E2E0936,0x2FC613AB,0x89B1181F,0x4C162691,0xEA612D25,0xDB8937B8,0x7DFE3C0C,
-        0xEC68D02B,0x4A1FDB9F,0x7BF7C102,0xDD80CAB6,0x1827F438,0xBE50FF8C,0x8FB8E511,0x29CFEEA5,
-        0xDF879E4C,0x79F095F8,0x48188F65,0xEE6F84D1,0x2BC8BA5F,0x8DBFB1EB,0xBC57AB76,0x1A20A0C2,
-        0x8816EAF2,0x2E61E146,0x1F89FBDB,0xB9FEF06F,0x7C59CEE1,0xDA2EC555,0xEBC6DFC8,0x4DB1D47C,
-        0xBBF9A495,0x1D8EAF21,0x2C66B5BC,0x8A11BE08,0x4FB68086,0xE9C18B32,0xD82991AF,0x7E5E9A1B,
-        0xEFC8763C,0x49BF7D88,0x78576715,0xDE206CA1,0x1B87522F,0xBDF0599B,0x8C184306,0x2A6F48B2,
-        0xDC27385B,0x7A5033EF,0x4BB82972,0xEDCF22C6,0x28681C48,0x8E1F17FC,0xBFF70D61,0x198006D5,
-        0x47ABD36E,0xE1DCD8DA,0xD034C247,0x7643C9F3,0xB3E4F77D,0x1593FCC9,0x247BE654,0x820CEDE0,
-        0x74449D09,0xD23396BD,0xE3DB8C20,0x45AC8794,0x800BB91A,0x267CB2AE,0x1794A833,0xB1E3A387,
-        0x20754FA0,0x86024414,0xB7EA5E89,0x119D553D,0xD43A6BB3,0x724D6007,0x43A57A9A,0xE5D2712E,
-        0x139A01C7,0xB5ED0A73,0x840510EE,0x22721B5A,0xE7D525D4,0x41A22E60,0x704A34FD,0xD63D3F49,
-        0xCC1D9F8B,0x6A6A943F,0x5B828EA2,0xFDF58516,0x3852BB98,0x9E25B02C,0xAFCDAAB1,0x09BAA105,
-        0xFFF2D1EC,0x5985DA58,0x686DC0C5,0xCE1ACB71,0x0BBDF5FF,0xADCAFE4B,0x9C22E4D6,0x3A55EF62,
-        0xABC30345,0x0DB408F1,0x3C5C126C,0x9A2B19D8,0x5F8C2756,0xF9FB2CE2,0xC813367F,0x6E643DCB,
-        0x982C4D22,0x3E5B4696,0x0FB35C0B,0xA9C457BF,0x6C636931,0xCA146285,0xFBFC7818,0x5D8B73AC,
-        0x03A0A617,0xA5D7ADA3,0x943FB73E,0x3248BC8A,0xF7EF8204,0x519889B0,0x6070932D,0xC6079899,
-        0x304FE870,0x9638E3C4,0xA7D0F959,0x01A7F2ED,0xC400CC63,0x6277C7D7,0x539FDD4A,0xF5E8D6FE,
-        0x647E3AD9,0xC209316D,0xF3E12BF0,0x55962044,0x90311ECA,0x3646157E,0x07AE0FE3,0xA1D90457,
-        0x579174BE,0xF1E67F0A,0xC00E6597,0x66796E23,0xA3DE50AD,0x05A95B19,0x34414184,0x92364A30
-    },
-
-    {
-        0x00000000,0xCCAA009E,0x4225077D,0x8E8F07E3,0x844A0EFA,0x48E00E64,0xC66F0987,0x0AC50919,
-        0xD3E51BB5,0x1F4F1B2B,0x91C01CC8,0x5D6A1C56,0x57AF154F,0x9B0515D1,0x158A1232,0xD92012AC,
-        0x7CBB312B,0xB01131B5,0x3E9E3656,0xF23436C8,0xF8F13FD1,0x345B3F4F,0xBAD438AC,0x767E3832,
-        0xAF5E2A9E,0x63F42A00,0xED7B2DE3,0x21D12D7D,0x2B142464,0xE7BE24FA,0x69312319,0xA59B2387,
-        0xF9766256,0x35DC62C8,0xBB53652B,0x77F965B5,0x7D3C6CAC,0xB1966C32,0x3F196BD1,0xF3B36B4F,
-        0x2A9379E3,0xE639797D,0x68B67E9E,0xA41C7E00,0xAED97719,0x62737787,0xECFC7064,0x205670FA,
-        0x85CD537D,0x496753E3,0xC7E85400,0x0B42549E,0x01875D87,0xCD2D5D19,0x43A25AFA,0x8F085A64,
-        0x562848C8,0x9A824856,0x140D4FB5,0xD8A74F2B,0xD2624632,0x1EC846AC,0x9047414F,0x5CED41D1,
-        0x299DC2ED,0xE537C273,0x6BB8C590,0xA712C50E,0xADD7CC17,0x617DCC89,0xEFF2CB6A,0x2358CBF4,
-        0xFA78D958,0x36D2D9C6,0xB85DDE25,0x74F7DEBB,0x7E32D7A2,0xB298D73C,0x3C17D0DF,0xF0BDD041,
-        0x5526F3C6,0x998CF358,0x1703F4BB,0xDBA9F425,0xD16CFD3C,0x1DC6FDA2,0x9349FA41,0x5FE3FADF,
-        0x86C3E873,0x4A69E8ED,0xC4E6EF0E,0x084CEF90,0x0289E689,0xCE23E617,0x40ACE1F4,0x8C06E16A,
-        0xD0EBA0BB,0x1C41A025,0x92CEA7C6,0x5E64A758,0x54A1AE41,0x980BAEDF,0x1684A93C,0xDA2EA9A2,
-        0x030EBB0E,0xCFA4BB90,0x412BBC73,0x8D81BCED,0x8744B5F4,0x4BEEB56A,0xC561B289,0x09CBB217,
-        0xAC509190,0x60FA910E,0xEE7596ED,0x22DF9673,0x281A9F6A,0xE4B09FF4,0x6A3F9817,0xA6959889,
-        0x7FB58A25,0xB31F8ABB,0x3D908D58,0xF13A8DC6,0xFBFF84DF,0x37558441,0xB9DA83A2,0x7570833C,
-        0x533B85DA,0x9F918544,0x111E82A7,0xDDB48239,0xD7718B20,0x1BDB8BBE,0x95548C5D,0x59FE8CC3,
-        0x80DE9E6F,0x4C749EF1,0xC2FB9912,0x0E51998C,0x04949095,0xC83E900B,0x46B197E8,0x8A1B9776,
-        0x2F80B4F1,0xE32AB46F,0x6DA5B38C,0xA10FB312,0xABCABA0B,0x6760BA95,0xE9EFBD76,0x2545BDE8,
-        0xFC65AF44,0x30CFAFDA,0xBE40A839,0x72EAA8A7,0x782FA1BE,0xB485A120,0x3A0AA6C3,0xF6A0A65D,
-        0xAA4DE78C,0x66E7E712,0xE868E0F1,0x24C2E06F,0x2E07E976,0xE2ADE9E8,0x6C22EE0B,0xA088EE95,
-        0x79A8FC39,0xB502FCA7,0x3B8DFB44,0xF727FBDA,0xFDE2F2C3,0x3148F25D,0xBFC7F5BE,0x736DF520,
-        0xD6F6D6A7,0x1A5CD639,0x94D3D1DA,0x5879D144,0x52BCD85D,0x9E16D8C3,0x1099DF20,0xDC33DFBE,
-        0x0513CD12,0xC9B9CD8C,0x4736CA6F,0x8B9CCAF1,0x8159C3E8,0x4DF3C376,0xC37CC495,0x0FD6C40B,
-        0x7AA64737,0xB60C47A9,0x3883404A,0xF42940D4,0xFEEC49CD,0x32464953,0xBCC94EB0,0x70634E2E,
-        0xA9435C82,0x65E95C1C,0xEB665BFF,0x27CC5B61,0x2D095278,0xE1A352E6,0x6F2C5505,0xA386559B,
-        0x061D761C,0xCAB77682,0x44387161,0x889271FF,0x825778E6,0x4EFD7878,0xC0727F9B,0x0CD87F05,
-        0xD5F86DA9,0x19526D37,0x97DD6AD4,0x5B776A4A,0x51B26353,0x9D1863CD,0x1397642E,0xDF3D64B0,
-        0x83D02561,0x4F7A25FF,0xC1F5221C,0x0D5F2282,0x079A2B9B,0xCB302B05,0x45BF2CE6,0x89152C78,
-        0x50353ED4,0x9C9F3E4A,0x121039A9,0xDEBA3937,0xD47F302E,0x18D530B0,0x965A3753,0x5AF037CD,
-        0xFF6B144A,0x33C114D4,0xBD4E1337,0x71E413A9,0x7B211AB0,0xB78B1A2E,0x39041DCD,0xF5AE1D53,
-        0x2C8E0FFF,0xE0240F61,0x6EAB0882,0xA201081C,0xA8C40105,0x646E019B,0xEAE10678,0x264B06E6
-    }
-};
+    {0x00000000, 0xA6770BB4, 0x979F1129, 0x31E81A9D, 0xF44F2413, 0x52382FA7, 0x63D0353A, 0xC5A73E8E, 0x33EF4E67,
+     0x959845D3, 0xA4705F4E, 0x020754FA, 0xC7A06A74, 0x61D761C0, 0x503F7B5D, 0xF64870E9, 0x67DE9CCE, 0xC1A9977A,
+     0xF0418DE7, 0x56368653, 0x9391B8DD, 0x35E6B369, 0x040EA9F4, 0xA279A240, 0x5431D2A9, 0xF246D91D, 0xC3AEC380,
+     0x65D9C834, 0xA07EF6BA, 0x0609FD0E, 0x37E1E793, 0x9196EC27, 0xCFBD399C, 0x69CA3228, 0x582228B5, 0xFE552301,
+     0x3BF21D8F, 0x9D85163B, 0xAC6D0CA6, 0x0A1A0712, 0xFC5277FB, 0x5A257C4F, 0x6BCD66D2, 0xCDBA6D66, 0x081D53E8,
+     0xAE6A585C, 0x9F8242C1, 0x39F54975, 0xA863A552, 0x0E14AEE6, 0x3FFCB47B, 0x998BBFCF, 0x5C2C8141, 0xFA5B8AF5,
+     0xCBB39068, 0x6DC49BDC, 0x9B8CEB35, 0x3DFBE081, 0x0C13FA1C, 0xAA64F1A8, 0x6FC3CF26, 0xC9B4C492, 0xF85CDE0F,
+     0x5E2BD5BB, 0x440B7579, 0xE27C7ECD, 0xD3946450, 0x75E36FE4, 0xB044516A, 0x16335ADE, 0x27DB4043, 0x81AC4BF7,
+     0x77E43B1E, 0xD19330AA, 0xE07B2A37, 0x460C2183, 0x83AB1F0D, 0x25DC14B9, 0x14340E24, 0xB2430590, 0x23D5E9B7,
+     0x85A2E203, 0xB44AF89E, 0x123DF32A, 0xD79ACDA4, 0x71EDC610, 0x4005DC8D, 0xE672D739, 0x103AA7D0, 0xB64DAC64,
+     0x87A5B6F9, 0x21D2BD4D, 0xE47583C3, 0x42028877, 0x73EA92EA, 0xD59D995E, 0x8BB64CE5, 0x2DC14751, 0x1C295DCC,
+     0xBA5E5678, 0x7FF968F6, 0xD98E6342, 0xE86679DF, 0x4E11726B, 0xB8590282, 0x1E2E0936, 0x2FC613AB, 0x89B1181F,
+     0x4C162691, 0xEA612D25, 0xDB8937B8, 0x7DFE3C0C, 0xEC68D02B, 0x4A1FDB9F, 0x7BF7C102, 0xDD80CAB6, 0x1827F438,
+     0xBE50FF8C, 0x8FB8E511, 0x29CFEEA5, 0xDF879E4C, 0x79F095F8, 0x48188F65, 0xEE6F84D1, 0x2BC8BA5F, 0x8DBFB1EB,
+     0xBC57AB76, 0x1A20A0C2, 0x8816EAF2, 0x2E61E146, 0x1F89FBDB, 0xB9FEF06F, 0x7C59CEE1, 0xDA2EC555, 0xEBC6DFC8,
+     0x4DB1D47C, 0xBBF9A495, 0x1D8EAF21, 0x2C66B5BC, 0x8A11BE08, 0x4FB68086, 0xE9C18B32, 0xD82991AF, 0x7E5E9A1B,
+     0xEFC8763C, 0x49BF7D88, 0x78576715, 0xDE206CA1, 0x1B87522F, 0xBDF0599B, 0x8C184306, 0x2A6F48B2, 0xDC27385B,
+     0x7A5033EF, 0x4BB82972, 0xEDCF22C6, 0x28681C48, 0x8E1F17FC, 0xBFF70D61, 0x198006D5, 0x47ABD36E, 0xE1DCD8DA,
+     0xD034C247, 0x7643C9F3, 0xB3E4F77D, 0x1593FCC9, 0x247BE654, 0x820CEDE0, 0x74449D09, 0xD23396BD, 0xE3DB8C20,
+     0x45AC8794, 0x800BB91A, 0x267CB2AE, 0x1794A833, 0xB1E3A387, 0x20754FA0, 0x86024414, 0xB7EA5E89, 0x119D553D,
+     0xD43A6BB3, 0x724D6007, 0x43A57A9A, 0xE5D2712E, 0x139A01C7, 0xB5ED0A73, 0x840510EE, 0x22721B5A, 0xE7D525D4,
+     0x41A22E60, 0x704A34FD, 0xD63D3F49, 0xCC1D9F8B, 0x6A6A943F, 0x5B828EA2, 0xFDF58516, 0x3852BB98, 0x9E25B02C,
+     0xAFCDAAB1, 0x09BAA105, 0xFFF2D1EC, 0x5985DA58, 0x686DC0C5, 0xCE1ACB71, 0x0BBDF5FF, 0xADCAFE4B, 0x9C22E4D6,
+     0x3A55EF62, 0xABC30345, 0x0DB408F1, 0x3C5C126C, 0x9A2B19D8, 0x5F8C2756, 0xF9FB2CE2, 0xC813367F, 0x6E643DCB,
+     0x982C4D22, 0x3E5B4696, 0x0FB35C0B, 0xA9C457BF, 0x6C636931, 0xCA146285, 0xFBFC7818, 0x5D8B73AC, 0x03A0A617,
+     0xA5D7ADA3, 0x943FB73E, 0x3248BC8A, 0xF7EF8204, 0x519889B0, 0x6070932D, 0xC6079899, 0x304FE870, 0x9638E3C4,
+     0xA7D0F959, 0x01A7F2ED, 0xC400CC63, 0x6277C7D7, 0x539FDD4A, 0xF5E8D6FE, 0x647E3AD9, 0xC209316D, 0xF3E12BF0,
+     0x55962044, 0x90311ECA, 0x3646157E, 0x07AE0FE3, 0xA1D90457, 0x579174BE, 0xF1E67F0A, 0xC00E6597, 0x66796E23,
+     0xA3DE50AD, 0x05A95B19, 0x34414184, 0x92364A30},
 
+    {0x00000000, 0xCCAA009E, 0x4225077D, 0x8E8F07E3, 0x844A0EFA, 0x48E00E64, 0xC66F0987, 0x0AC50919, 0xD3E51BB5,
+     0x1F4F1B2B, 0x91C01CC8, 0x5D6A1C56, 0x57AF154F, 0x9B0515D1, 0x158A1232, 0xD92012AC, 0x7CBB312B, 0xB01131B5,
+     0x3E9E3656, 0xF23436C8, 0xF8F13FD1, 0x345B3F4F, 0xBAD438AC, 0x767E3832, 0xAF5E2A9E, 0x63F42A00, 0xED7B2DE3,
+     0x21D12D7D, 0x2B142464, 0xE7BE24FA, 0x69312319, 0xA59B2387, 0xF9766256, 0x35DC62C8, 0xBB53652B, 0x77F965B5,
+     0x7D3C6CAC, 0xB1966C32, 0x3F196BD1, 0xF3B36B4F, 0x2A9379E3, 0xE639797D, 0x68B67E9E, 0xA41C7E00, 0xAED97719,
+     0x62737787, 0xECFC7064, 0x205670FA, 0x85CD537D, 0x496753E3, 0xC7E85400, 0x0B42549E, 0x01875D87, 0xCD2D5D19,
+     0x43A25AFA, 0x8F085A64, 0x562848C8, 0x9A824856, 0x140D4FB5, 0xD8A74F2B, 0xD2624632, 0x1EC846AC, 0x9047414F,
+     0x5CED41D1, 0x299DC2ED, 0xE537C273, 0x6BB8C590, 0xA712C50E, 0xADD7CC17, 0x617DCC89, 0xEFF2CB6A, 0x2358CBF4,
+     0xFA78D958, 0x36D2D9C6, 0xB85DDE25, 0x74F7DEBB, 0x7E32D7A2, 0xB298D73C, 0x3C17D0DF, 0xF0BDD041, 0x5526F3C6,
+     0x998CF358, 0x1703F4BB, 0xDBA9F425, 0xD16CFD3C, 0x1DC6FDA2, 0x9349FA41, 0x5FE3FADF, 0x86C3E873, 0x4A69E8ED,
+     0xC4E6EF0E, 0x084CEF90, 0x0289E689, 0xCE23E617, 0x40ACE1F4, 0x8C06E16A, 0xD0EBA0BB, 0x1C41A025, 0x92CEA7C6,
+     0x5E64A758, 0x54A1AE41, 0x980BAEDF, 0x1684A93C, 0xDA2EA9A2, 0x030EBB0E, 0xCFA4BB90, 0x412BBC73, 0x8D81BCED,
+     0x8744B5F4, 0x4BEEB56A, 0xC561B289, 0x09CBB217, 0xAC509190, 0x60FA910E, 0xEE7596ED, 0x22DF9673, 0x281A9F6A,
+     0xE4B09FF4, 0x6A3F9817, 0xA6959889, 0x7FB58A25, 0xB31F8ABB, 0x3D908D58, 0xF13A8DC6, 0xFBFF84DF, 0x37558441,
+     0xB9DA83A2, 0x7570833C, 0x533B85DA, 0x9F918544, 0x111E82A7, 0xDDB48239, 0xD7718B20, 0x1BDB8BBE, 0x95548C5D,
+     0x59FE8CC3, 0x80DE9E6F, 0x4C749EF1, 0xC2FB9912, 0x0E51998C, 0x04949095, 0xC83E900B, 0x46B197E8, 0x8A1B9776,
+     0x2F80B4F1, 0xE32AB46F, 0x6DA5B38C, 0xA10FB312, 0xABCABA0B, 0x6760BA95, 0xE9EFBD76, 0x2545BDE8, 0xFC65AF44,
+     0x30CFAFDA, 0xBE40A839, 0x72EAA8A7, 0x782FA1BE, 0xB485A120, 0x3A0AA6C3, 0xF6A0A65D, 0xAA4DE78C, 0x66E7E712,
+     0xE868E0F1, 0x24C2E06F, 0x2E07E976, 0xE2ADE9E8, 0x6C22EE0B, 0xA088EE95, 0x79A8FC39, 0xB502FCA7, 0x3B8DFB44,
+     0xF727FBDA, 0xFDE2F2C3, 0x3148F25D, 0xBFC7F5BE, 0x736DF520, 0xD6F6D6A7, 0x1A5CD639, 0x94D3D1DA, 0x5879D144,
+     0x52BCD85D, 0x9E16D8C3, 0x1099DF20, 0xDC33DFBE, 0x0513CD12, 0xC9B9CD8C, 0x4736CA6F, 0x8B9CCAF1, 0x8159C3E8,
+     0x4DF3C376, 0xC37CC495, 0x0FD6C40B, 0x7AA64737, 0xB60C47A9, 0x3883404A, 0xF42940D4, 0xFEEC49CD, 0x32464953,
+     0xBCC94EB0, 0x70634E2E, 0xA9435C82, 0x65E95C1C, 0xEB665BFF, 0x27CC5B61, 0x2D095278, 0xE1A352E6, 0x6F2C5505,
+     0xA386559B, 0x061D761C, 0xCAB77682, 0x44387161, 0x889271FF, 0x825778E6, 0x4EFD7878, 0xC0727F9B, 0x0CD87F05,
+     0xD5F86DA9, 0x19526D37, 0x97DD6AD4, 0x5B776A4A, 0x51B26353, 0x9D1863CD, 0x1397642E, 0xDF3D64B0, 0x83D02561,
+     0x4F7A25FF, 0xC1F5221C, 0x0D5F2282, 0x079A2B9B, 0xCB302B05, 0x45BF2CE6, 0x89152C78, 0x50353ED4, 0x9C9F3E4A,
+     0x121039A9, 0xDEBA3937, 0xD47F302E, 0x18D530B0, 0x965A3753, 0x5AF037CD, 0xFF6B144A, 0x33C114D4, 0xBD4E1337,
+     0x71E413A9, 0x7B211AB0, 0xB78B1A2E, 0x39041DCD, 0xF5AE1D53, 0x2C8E0FFF, 0xE0240F61, 0x6EAB0882, 0xA201081C,
+     0xA8C40105, 0x646E019B, 0xEAE10678, 0x264B06E6}};
 
 uint32_t Crc32::get(const void* data, size_t len, uint32_t seed) {
     uint32_t* cur = (uint32_t*)data;
@@ -348,19 +307,14 @@ uint32_t Crc32::get(const void* data, size_t len, uint32_t seed) {
 
         uint32_t one = *cur++ ^ crc;
         uint32_t two = *cur++;
-        crc = crc_lookup[7][(one    ) & 0xFF] ^
-              crc_lookup[6][(one>> 8) & 0xFF] ^
-              crc_lookup[5][(one>>16) & 0xFF] ^
-              crc_lookup[4][(one>>24) & 0xFF] ^
-              crc_lookup[3][(two    ) & 0xFF] ^
-              crc_lookup[2][(two>> 8) & 0xFF] ^
-              crc_lookup[1][(two>>16) & 0xFF] ^
-              crc_lookup[0][(two>>24) & 0xFF];
+        crc = crc_lookup[7][(one) & 0xFF] ^ crc_lookup[6][(one >> 8) & 0xFF] ^ crc_lookup[5][(one >> 16) & 0xFF] ^
+            crc_lookup[4][(one >> 24) & 0xFF] ^ crc_lookup[3][(two) & 0xFF] ^ crc_lookup[2][(two >> 8) & 0xFF] ^
+            crc_lookup[1][(two >> 16) & 0xFF] ^ crc_lookup[0][(two >> 24) & 0xFF];
 #endif
         len -= 8;
     }
 
-    unsigned char *cur_byte = (unsigned char*)cur;
+    unsigned char* cur_byte = (unsigned char*)cur;
     while (len--) {
         crc = (crc >> 8) ^ crc_lookup[0][(crc & 0xFF) ^ *cur_byte++];
     }
@@ -368,13 +322,8 @@ uint32_t Crc32::get(const void* data, size_t len, uint32_t seed) {
     return ~crc;
 }
 
-uint32_t Crc32::get(const SEBuf& buf, uint32_t seed) {
-    return get(buf.buf, buf.len, seed);
-}
-
-uint32_t Crc32::get(const std::string& str, uint32_t seed) {
-    return get(str.data(), str.size(), seed);
-}
+uint32_t Crc32::get(const SEBuf& buf, uint32_t seed) { return get(buf.buf, buf.len, seed); }
 
-};
+uint32_t Crc32::get(const std::string& str, uint32_t seed) { return get(str.data(), str.size(), seed); }
 
+}; // namespace nukv
diff --git a/src/replication/repl_log_store/lib/endian_encode.h b/src/replication/repl_log_store/lib/endian_encode.h
index 5b2d01d9e..7f662e1a6 100644
--- a/src/replication/repl_log_store/lib/endian_encode.h
+++ b/src/replication/repl_log_store/lib/endian_encode.h
@@ -42,18 +42,19 @@
 
 #ifndef reverse_order_64
 #define reverse_order_64(v)                                                                                            \
-    ((((v)&0xff00000000000000ULL) >> 56) | (((v)&0x00ff000000000000ULL) >> 40) | (((v)&0x0000ff0000000000ULL) >> 24) | \
-     (((v)&0x000000ff00000000ULL) >> 8) | (((v)&0x00000000ff000000ULL) << 8) | (((v)&0x0000000000ff0000ULL) << 24) |   \
-     (((v)&0x000000000000ff00ULL) << 40) | (((v)&0x00000000000000ffULL) << 56))
+    ((((v) & 0xff00000000000000ULL) >> 56) | (((v) & 0x00ff000000000000ULL) >> 40) |                                   \
+     (((v) & 0x0000ff0000000000ULL) >> 24) | (((v) & 0x000000ff00000000ULL) >> 8) |                                    \
+     (((v) & 0x00000000ff000000ULL) << 8) | (((v) & 0x0000000000ff0000ULL) << 24) |                                    \
+     (((v) & 0x000000000000ff00ULL) << 40) | (((v) & 0x00000000000000ffULL) << 56))
 #endif
 
 #ifndef reverse_order_32
 #define reverse_order_32(v)                                                                                            \
-    ((((v)&0xff000000) >> 24) | (((v)&0x00ff0000) >> 8) | (((v)&0x0000ff00) << 8) | (((v)&0x000000ff) << 24))
+    ((((v) & 0xff000000) >> 24) | (((v) & 0x00ff0000) >> 8) | (((v) & 0x0000ff00) << 8) | (((v) & 0x000000ff) << 24))
 #endif
 
 #ifndef reverse_order_16
-#define reverse_order_16(v) ((((v)&0xff00) >> 8) | (((v)&0x00ff) << 8))
+#define reverse_order_16(v) ((((v) & 0xff00) >> 8) | (((v) & 0x00ff) << 8))
 #endif
 
 #if defined(_LITTLE_ENDIAN)
diff --git a/src/replication/repl_log_store/lib/hex_dump.h b/src/replication/repl_log_store/lib/hex_dump.h
index 7446a71ee..d1099318e 100644
--- a/src/replication/repl_log_store/lib/hex_dump.h
+++ b/src/replication/repl_log_store/lib/hex_dump.h
@@ -104,8 +104,7 @@ struct print_hex_options {
     int align;
 };
 
-#define PRINT_HEX_OPTIONS_INITIALIZER                                                                                  \
-    (struct print_hex_options) { 1, 1, 16 }
+#define PRINT_HEX_OPTIONS_INITIALIZER (struct print_hex_options){1, 1, 16}
 
 static void _print_white_space(FILE* stream, size_t len) {
     for (size_t i = 0; i < len; ++i) {
@@ -113,8 +112,8 @@ static void _print_white_space(FILE* stream, size_t len) {
     }
 }
 
-static void __attribute__((unused))
-print_hex_stream(FILE* stream, const void* buf, size_t buflen, struct print_hex_options options) {
+static void __attribute__((unused)) print_hex_stream(FILE* stream, const void* buf, size_t buflen,
+                                                     struct print_hex_options options) {
     size_t i, j;
     size_t max_addr_len;
     char str_buffer[256];
diff --git a/src/replication/repl_log_store/lib/stat.cc b/src/replication/repl_log_store/lib/stat.cc
index e49cfb111..55ef8da0d 100644
--- a/src/replication/repl_log_store/lib/stat.cc
+++ b/src/replication/repl_log_store/lib/stat.cc
@@ -11,29 +11,23 @@
 #include "common.h"
 #include "stat.h"
 
-std::atomic<StatMgr*> StatMgr::instance(nullptr);
+std::atomic< StatMgr* > StatMgr::instance(nullptr);
 std::mutex StatMgr::instanceLock;
 
-StatElem::StatElem(Type _type, const std::string& _name)
-    : statType(_type)
-    , statName(_name)
-    , counter(0)
-    , gauge(0)
-    , hist( (_type == HISTOGRAM)
-            ?(new Histogram())
-            :(nullptr) ) {}
-
-StatElem::~StatElem() {
-    delete hist;
-}
+StatElem::StatElem(Type _type, const std::string& _name) :
+        statType(_type),
+        statName(_name),
+        counter(0),
+        gauge(0),
+        hist((_type == HISTOGRAM) ? (new Histogram()) : (nullptr)) {}
 
+StatElem::~StatElem() { delete hist; }
 
-StatMgr::StatMgr() {
-}
+StatMgr::StatMgr() {}
 
 StatMgr::~StatMgr() {
-    std::unique_lock<std::mutex> l(statMapLock);
-    for (auto& entry: statMap) {
+    std::unique_lock< std::mutex > l(statMapLock);
+    for (auto& entry : statMap) {
         delete entry.second;
     }
 }
@@ -41,7 +35,7 @@ StatMgr::~StatMgr() {
 StatMgr* StatMgr::init() {
     StatMgr* mgr = instance.load();
     if (!mgr) {
-        std::lock_guard<std::mutex> l(instanceLock);
+        std::lock_guard< std::mutex > l(instanceLock);
         mgr = instance.load();
         if (!mgr) {
             mgr = new StatMgr();
@@ -58,7 +52,7 @@ StatMgr* StatMgr::getInstance() {
 }
 
 void StatMgr::destroy() {
-    std::lock_guard<std::mutex> l(instanceLock);
+    std::lock_guard< std::mutex > l(instanceLock);
     StatMgr* mgr = instance.load();
     if (mgr) {
         delete mgr;
@@ -138,24 +132,21 @@ StatMgr::CpuStat StatMgr::getCpuStat() {
     // TODO: other platforms
 
     {
-        std::lock_guard<std::mutex> l(last_numbers_lock);
+        std::lock_guard< std::mutex > l(last_numbers_lock);
         static uint64_t last_user_time = 0;
         static uint64_t last_kernel_time = 0;
         static uint64_t last_user_millicores = 0;
         static uint64_t last_kernel_millicores = 0;
 
-        if ( last_user_time && last_kernel_time &&
-                last_user_time <= ret.userTimeMs &&
-                last_kernel_time <= ret.kernelTimeMs ) {
+        if (last_user_time && last_kernel_time && last_user_time <= ret.userTimeMs &&
+            last_kernel_time <= ret.kernelTimeMs) {
             uint64_t time_gap_us = timer.getElapsedUs();
             // Minimum gap should be bigger than 1 second.
             if (time_gap_us >= 1000000) {
                 uint64_t user_time_gap = ret.userTimeMs - last_user_time;
                 uint64_t kernel_time_gap = ret.kernelTimeMs - last_kernel_time;
-                ret.userMilliCores =
-                    1000 * (user_time_gap * 1000) / time_gap_us;
-                ret.kernelMilliCores =
-                    1000 * (kernel_time_gap * 1000) / time_gap_us;
+                ret.userMilliCores = 1000 * (user_time_gap * 1000) / time_gap_us;
+                ret.kernelMilliCores = 1000 * (kernel_time_gap * 1000) / time_gap_us;
 
                 timer.reset();
                 last_user_time = ret.userTimeMs;
@@ -225,9 +216,8 @@ StatMgr::IoStat StatMgr::getIoStat(const std::string& path) {
     do {
         size_t dev_major = 0, dev_minor = 0;
         fs >> dev_major >> dev_minor;
-        if ( dev_major != major(ss.st_dev) ||
-                dev_minor != minor(ss.st_dev) ) {
-            fs.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        if (dev_major != major(ss.st_dev) || dev_minor != minor(ss.st_dev)) {
+            fs.ignore(std::numeric_limits< std::streamsize >::max(), '\n');
             continue;
         }
 
@@ -240,9 +230,7 @@ StatMgr::IoStat StatMgr::getIoStat(const std::string& path) {
 
     // Get device name from partition name.
     std::string dev_name;
-    if (!partition_name.empty()) {
-        dev_name = partition_name.substr(0, partition_name.size() - 1);
-    }
+    if (!partition_name.empty()) { dev_name = partition_name.substr(0, partition_name.size() - 1); }
 
     // Rewind.
     fs.seekg(0, fs.beg);
@@ -253,7 +241,7 @@ StatMgr::IoStat StatMgr::getIoStat(const std::string& path) {
         std::string dummy_str;
         fs >> dummy_str;
         if (dummy_str != dev_name) {
-            fs.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            fs.ignore(std::numeric_limits< std::streamsize >::max(), '\n');
             continue;
         }
 
@@ -264,8 +252,8 @@ StatMgr::IoStat StatMgr::getIoStat(const std::string& path) {
     } while (!fs.eof());
     fs.close();
 
-    FILE *fp = fopen("/proc/self/io", "r");
-    while(!feof(fp)) {
+    FILE* fp = fopen("/proc/self/io", "r");
+    while (!feof(fp)) {
         char str[64];
         unsigned long temp;
         int rr = fscanf(fp, "%s %lu", str, &temp);
@@ -279,7 +267,7 @@ StatMgr::IoStat StatMgr::getIoStat(const std::string& path) {
 
     // Calculate time-based metrics.
     {
-        std::lock_guard<std::mutex> l(last_numbers_lock);
+        std::lock_guard< std::mutex > l(last_numbers_lock);
         static uint64_t last_time_io_p = 0;
         static uint64_t last_time_io_d = 0;
         static uint64_t last_time_r = 0;
@@ -297,20 +285,14 @@ StatMgr::IoStat StatMgr::getIoStat(const std::string& path) {
         // Minimum gap should be bigger than 0.5 second.
         uint64_t gap_ms = timer.getElapsedMs();
         if (gap_ms >= 500) {
-            last_util_p = (time_io_p >= last_time_io_p)
-                          ? (time_io_p - last_time_io_p) * 1000 / gap_ms
-                          : 0;
-            last_util_d = (time_io_d >= last_time_io_d)
-                          ? (time_io_d - last_time_io_d) * 1000 / gap_ms
-                          : 0;
+            last_util_p = (time_io_p >= last_time_io_p) ? (time_io_p - last_time_io_p) * 1000 / gap_ms : 0;
+            last_util_d = (time_io_d >= last_time_io_d) ? (time_io_d - last_time_io_d) * 1000 / gap_ms : 0;
             last_avg_r = (time_r >= last_time_r && ret.numReads > last_num_r)
-                         ? ( (time_r - last_time_r) * 1000 /
-                             (ret.numReads - last_num_r) )
-                         : 0;
+                ? ((time_r - last_time_r) * 1000 / (ret.numReads - last_num_r))
+                : 0;
             last_avg_w = (time_w >= last_time_w && ret.numWrites > last_num_w)
-                         ? ( (time_w - last_time_w) * 1000 /
-                             (ret.numWrites - last_num_w) )
-                         : 0;
+                ? ((time_w - last_time_w) * 1000 / (ret.numWrites - last_num_w))
+                : 0;
 
             update_prev_stats = true;
 
@@ -355,7 +337,7 @@ uint64_t StatMgr::getDiskUsage(const std::string& path) {
 }
 
 StatElem* StatMgr::getStat(const std::string& stat_name) {
-    std::unique_lock<std::mutex> l(statMapLock);
+    std::unique_lock< std::mutex > l(statMapLock);
     auto entry = statMap.find(stat_name);
     if (entry == statMap.end()) {
         // Not exist.
@@ -367,26 +349,22 @@ StatElem* StatMgr::getStat(const std::string& stat_name) {
 StatElem* StatMgr::createStat(StatElem::Type type, const std::string& stat_name) {
     StatElem* elem = new StatElem(type, stat_name);
 
-    std::unique_lock<std::mutex> l(statMapLock);
+    std::unique_lock< std::mutex > l(statMapLock);
     auto entry = statMap.find(stat_name);
     if (entry != statMap.end()) {
         // Alraedy exist.
         delete elem;
         return entry->second;
     }
-    statMap.insert( std::make_pair(stat_name, elem) );
+    statMap.insert(std::make_pair(stat_name, elem));
     return elem;
 }
 
-void StatMgr::getAllStats(std::vector<StatElem*>& stats_out) {
-    std::unique_lock<std::mutex> l(statMapLock);
+void StatMgr::getAllStats(std::vector< StatElem* >& stats_out) {
+    std::unique_lock< std::mutex > l(statMapLock);
     stats_out.resize(statMap.size());
     size_t idx = 0;
-    for (auto& entry: statMap) {
+    for (auto& entry : statMap) {
         stats_out[idx++] = entry.second;
     }
 }
-
-
-
-
diff --git a/src/test_common/homestore_test_common.hpp b/src/test_common/homestore_test_common.hpp
index 33aacbb04..fbed818cd 100644
--- a/src/test_common/homestore_test_common.hpp
+++ b/src/test_common/homestore_test_common.hpp
@@ -31,7 +31,7 @@ const std::string USER_WANT_DIRECT_IO{"USER_WANT_DIRECT_IO"};               // u
 namespace test_common {
 
 // Fix a port for http server
-inline static void set_fixed_http_port(uint32_t http_port){
+inline static void set_fixed_http_port(uint32_t http_port) {
     IM_SETTINGS_FACTORY().modifiable_settings([http_port](auto& s) { s.io_env->http_port = http_port; });
     IM_SETTINGS_FACTORY().save();
     LOGINFO("http port = {}", http_port);

From b58dc1b415c4f310ebf35e8a9785165cca52dcdc Mon Sep 17 00:00:00 2001
From: Mehdi Hosseini <shosseinimotlagh@ebay.com>
Date: Fri, 8 May 2026 12:06:02 -0700
Subject: [PATCH 10/10]  update locks

---
 conanfile.py             | 2 +-
 locks/base.lock          | 2 +-
 locks/debug_deps.lock    | 2 +-
 locks/release_deps.lock  | 2 +-
 locks/sanitize_deps.lock | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/conanfile.py b/conanfile.py
index 9da2f057a..de4a8a9ff 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -2,7 +2,7 @@
 
 class HomestoreConan(ConanFile):
     name = "homestore"
-    version = "3.8.6"
+    version = "3.8.7"
 
     homepage = "https://github.corp.ebay.com/SDS/homestore"
     description = "HomeStore"
diff --git a/locks/base.lock b/locks/base.lock
index 839ff43ab..9291bb59a 100644
--- a/locks/base.lock
+++ b/locks/base.lock
@@ -2,7 +2,7 @@
  "graph_lock": {
   "nodes": {
    "0": {
-    "ref": "homestore/3.8.6",
+    "ref": "homestore/3.8.7",
     "requires": [
      "1",
      "2",
diff --git a/locks/debug_deps.lock b/locks/debug_deps.lock
index 6a9010012..2d3ea7ad1 100644
--- a/locks/debug_deps.lock
+++ b/locks/debug_deps.lock
@@ -2,7 +2,7 @@
  "graph_lock": {
   "nodes": {
    "0": {
-    "ref": "homestore/3.8.6",
+    "ref": "homestore/3.8.7",
     "options": "coverage=False\nfPIC=True\nsanitize=False\nshared=False\nskip_testing=False\ntesting=epoll_mode\nabseil:fPIC=True\nabseil:shared=False\nboost:addr2line_location=/usr/bin/addr2line\nboost:asio_no_deprecated=False\nboost:buildid=None\nboost:bzip2=True\nboost:debug_level=0\nboost:diagnostic_definitions=False\nboost:error_code_header_only=False\nboost:extra_b2_flags=None\nboost:fPIC=True\nboost:filesystem_no_deprecated=False\nboost:filesystem_version=None\nboost:header_only=False\nboost:i18n_backend=deprecated\nboost:i18n_backend_iconv=libc\nboost:i18n_backend_icu=False\nboost:layout=system\nboost:lzma=False\nboost:magic_autolink=False\nboost:multithreading=True\nboost:namespace=boost\nboost:namespace_alias=False\nboost:numa=True\nboost:pch=True\nboost:python_executable=None\nboost:python_version=None\nboost:segmented_stacks=False\nboost:shared=False\nboost:system_no_deprecated=False\nboost:system_use_utf8=False\nboost:visibility=hidden\nboost:with_stacktrace_backtrace=True\nboost:without_atomic=False\nboost:without_chrono=False\nboost:without_container=False\nboost:without_context=False\nboost:without_contract=False\nboost:without_coroutine=False\nboost:without_date_time=False\nboost:without_exception=False\nboost:without_fiber=False\nboost:without_filesystem=False\nboost:without_graph=False\nboost:without_graph_parallel=True\nboost:without_iostreams=False\nboost:without_json=False\nboost:without_locale=False\nboost:without_log=False\nboost:without_math=False\nboost:without_mpi=True\nboost:without_nowide=False\nboost:without_program_options=False\nboost:without_python=True\nboost:without_random=False\nboost:without_regex=False\nboost:without_serialization=False\nboost:without_stacktrace=False\nboost:without_system=False\nboost:without_test=False\nboost:without_thread=False\nboost:without_timer=False\nboost:without_type_erasure=False\nboost:without_wave=False\nboost:zlib=True\nboost:zstd=False\nbreakpad:fPIC=True\nbzip2:build_executable=True\nbzip2:fPIC=True\nbzip2:shared=False\nc-ares:fPIC=True\nc-ares:shared=False\nc-ares:tools=True\ncivetweb:fPIC=True\ncivetweb:shared=False\ncivetweb:ssl_dynamic_loading=False\ncivetweb:with_caching=True\ncivetweb:with_cgi=True\ncivetweb:with_cxx=True\ncivetweb:with_duktape=False\ncivetweb:with_ipv6=True\ncivetweb:with_lua=False\ncivetweb:with_server_stats=False\ncivetweb:with_ssl=True\ncivetweb:with_static_files=True\ncivetweb:with_third_party_output=False\ncivetweb:with_websockets=True\ncivetweb:with_zlib=False\ncpr:fPIC=True\ncpr:shared=False\ncpr:signal=True\ncpr:with_ssl=auto\ncxxopts:unicode=False\ndate:fPIC=True\ndate:header_only=False\ndate:shared=False\ndate:use_system_tz_db=False\ndate:use_tz_db_in_dot=False\ndouble-conversion:fPIC=True\ndouble-conversion:shared=False\ndpdk:fPIC=True\ndpdk:native_build=False\ndpdk:numa=False\ndpdk:shared=False\nfarmhash:fPIC=True\nfarmhash:no_builtin_expect=False\nfarmhash:shared=False\nfio:native_build=False\nflatbuffers:fPIC=True\nflatbuffers:header_only=False\nflatbuffers:shared=False\nfmt:fPIC=True\nfmt:header_only=False\nfmt:shared=False\nfmt:with_fmt_alias=False\nfmt:with_os_api=True\nfolly:fPIC=True\nfolly:shared=False\nfolly:use_sse4_2=False\ngflags:fPIC=True\ngflags:namespace=gflags\ngflags:nothreads=True\ngflags:shared=False\nglog:fPIC=True\nglog:shared=False\nglog:with_gflags=True\nglog:with_threads=True\ngperftools:fPIC=True\ngperftools:shared=False\ngrpc:codegen=True\ngrpc:cpp_plugin=True\ngrpc:csharp_ext=False\ngrpc:csharp_plugin=True\ngrpc:fPIC=True\ngrpc:node_plugin=True\ngrpc:objective_c_plugin=True\ngrpc:php_plugin=True\ngrpc:python_plugin=True\ngrpc:ruby_plugin=True\ngrpc:secure=False\ngrpc:shared=False\niomgr:coverage=False\niomgr:fPIC=True\niomgr:sanitize=False\niomgr:shared=False\niomgr:testing=epoll_mode\nisa-l:fPIC=True\nisa-l:shared=False\nlibbacktrace:fPIC=True\nlibbacktrace:shared=False\nlibcap:fPIC=True\nlibcap:psx_syscals=False\nlibcap:shared=False\nlibcurl:fPIC=True\nlibcurl:shared=False\nlibcurl:with_brotli=False\nlibcurl:with_c_ares=False\nlibcurl:with_ca_bundle=auto\nlibcurl:with_ca_fallback=False\nlibcurl:with_ca_path=auto\nlibcurl:with_cookies=True\nlibcurl:with_crypto_auth=True\nlibcurl:with_dict=True\nlibcurl:with_docs=False\nlibcurl:with_file=True\nlibcurl:with_ftp=True\nlibcurl:with_gopher=True\nlibcurl:with_http=True\nlibcurl:with_imap=True\nlibcurl:with_ipv6=True\nlibcurl:with_largemaxwritesize=False\nlibcurl:with_ldap=False\nlibcurl:with_libgsasl=False\nlibcurl:with_libidn=False\nlibcurl:with_libpsl=False\nlibcurl:with_librtmp=False\nlibcurl:with_libssh2=False\nlibcurl:with_mqtt=True\nlibcurl:with_nghttp2=False\nlibcurl:with_ntlm=True\nlibcurl:with_ntlm_wb=True\nlibcurl:with_pop3=True\nlibcurl:with_proxy=True\nlibcurl:with_rtsp=True\nlibcurl:with_smb=True\nlibcurl:with_smtp=True\nlibcurl:with_ssl=openssl\nlibcurl:with_symbol_hiding=False\nlibcurl:with_telnet=True\nlibcurl:with_tftp=True\nlibcurl:with_threaded_resolver=True\nlibcurl:with_unix_sockets=True\nlibcurl:with_verbose_debug=True\nlibcurl:with_verbose_strings=True\nlibcurl:with_zlib=True\nlibcurl:with_zstd=False\nlibdwarf:fPIC=True\nlibdwarf:shared=False\nlibdwarf:with_dwarfgen=False\nlibelf:fPIC=True\nlibelf:shared=False\nlibevent:disable_threads=False\nlibevent:fPIC=True\nlibevent:shared=False\nlibevent:with_openssl=True\nlibiberty:fPIC=True\nlibmount:fPIC=True\nlibmount:shared=False\nlibselinux:fPIC=True\nlibselinux:shared=False\nlibsodium:PIE=False\nlibsodium:fPIC=True\nlibsodium:shared=False\nlibsodium:use_soname=True\nlibsystemd:fPIC=True\nlibsystemd:shared=False\nlibsystemd:with_lz4=True\nlibsystemd:with_selinux=True\nlibsystemd:with_xz=True\nlibsystemd:with_zstd=True\nlibunwind:coredump=True\nlibunwind:fPIC=True\nlibunwind:minidebuginfo=True\nlibunwind:ptrace=True\nlibunwind:setjmp=True\nlibunwind:shared=False\nlibunwind:zlibdebuginfo=True\nliburing:fPIC=True\nliburing:shared=False\nlibxcrypt:fPIC=True\nlibxcrypt:shared=False\nlz4:fPIC=True\nlz4:shared=False\nopenssl:386=False\nopenssl:enable_trace=False\nopenssl:enable_weak_ssl_ciphers=False\nopenssl:fPIC=True\nopenssl:no_apps=False\nopenssl:no_aria=False\nopenssl:no_asm=False\nopenssl:no_async=False\nopenssl:no_autoload_config=False\nopenssl:no_bf=False\nopenssl:no_blake2=False\nopenssl:no_camellia=False\nopenssl:no_cast=False\nopenssl:no_chacha=False\nopenssl:no_cms=False\nopenssl:no_comp=False\nopenssl:no_ct=False\nopenssl:no_deprecated=False\nopenssl:no_des=False\nopenssl:no_dgram=False\nopenssl:no_dh=False\nopenssl:no_dsa=False\nopenssl:no_dso=False\nopenssl:no_ec=False\nopenssl:no_ecdh=False\nopenssl:no_ecdsa=False\nopenssl:no_engine=False\nopenssl:no_filenames=False\nopenssl:no_fips=False\nopenssl:no_gost=False\nopenssl:no_idea=False\nopenssl:no_legacy=False\nopenssl:no_md2=True\nopenssl:no_md4=False\nopenssl:no_mdc2=False\nopenssl:no_module=False\nopenssl:no_ocsp=False\nopenssl:no_pinshared=False\nopenssl:no_rc2=False\nopenssl:no_rc4=False\nopenssl:no_rc5=False\nopenssl:no_rfc3779=False\nopenssl:no_rmd160=False\nopenssl:no_seed=False\nopenssl:no_sm2=False\nopenssl:no_sm3=False\nopenssl:no_sm4=False\nopenssl:no_sock=False\nopenssl:no_srp=False\nopenssl:no_srtp=False\nopenssl:no_sse2=False\nopenssl:no_ssl=False\nopenssl:no_ssl3=False\nopenssl:no_stdio=False\nopenssl:no_threads=False\nopenssl:no_tls1=False\nopenssl:no_ts=False\nopenssl:no_whirlpool=False\nopenssl:no_zlib=False\nopenssl:openssldir=None\nopenssl:shared=False\nopenssl:tls_security_level=None\npcre2:build_pcre2_16=True\npcre2:build_pcre2_32=True\npcre2:build_pcre2_8=True\npcre2:build_pcre2grep=True\npcre2:fPIC=True\npcre2:grep_support_callout_fork=True\npcre2:link_size=2\npcre2:shared=False\npcre2:support_jit=False\npcre2:with_bzip2=True\npcre2:with_zlib=True\npistache:fPIC=True\npistache:shared=False\npistache:with_ssl=True\nprometheus-cpp:fPIC=True\nprometheus-cpp:shared=False\nprometheus-cpp:with_compression=True\nprometheus-cpp:with_pull=True\nprometheus-cpp:with_push=True\nprotobuf:debug_suffix=True\nprotobuf:fPIC=True\nprotobuf:lite=False\nprotobuf:shared=False\nprotobuf:with_rtti=True\nprotobuf:with_zlib=True\nre2:fPIC=True\nre2:shared=False\nre2:with_icu=False\nsisl:coverage=False\nsisl:fPIC=True\nsisl:malloc_impl=tcmalloc\nsisl:prerelease=True\nsisl:sanitize=False\nsisl:shared=False\nsnappy:fPIC=True\nsnappy:shared=False\nsnappy:with_bmi2=auto\nsnappy:with_ssse3=auto\nspdk:fPIC=True\nspdk:native_build=True\nspdk:shared=False\nspdlog:fPIC=True\nspdlog:header_only=False\nspdlog:no_exceptions=False\nspdlog:shared=False\nspdlog:wchar_filenames=False\nspdlog:wchar_support=False\nuserspace-rcu:fPIC=True\nuserspace-rcu:model=generic\nuserspace-rcu:shared=False\nxz_utils:fPIC=True\nxz_utils:shared=False\nzlib:fPIC=True\nzlib:shared=False\nzmarok-semver:fPIC=True\nzmarok-semver:shared=False\nzstd:fPIC=True\nzstd:shared=False\nzstd:threading=True",
     "requires": [
      "1",
diff --git a/locks/release_deps.lock b/locks/release_deps.lock
index a0c6dbd71..b20a4bb67 100644
--- a/locks/release_deps.lock
+++ b/locks/release_deps.lock
@@ -2,7 +2,7 @@
  "graph_lock": {
   "nodes": {
    "0": {
-    "ref": "homestore/3.8.6",
+    "ref": "homestore/3.8.7",
     "options": "coverage=False\nfPIC=True\nsanitize=False\nshared=False\nskip_testing=False\ntesting=epoll_mode\nabseil:fPIC=True\nabseil:shared=False\nboost:addr2line_location=/usr/bin/addr2line\nboost:asio_no_deprecated=False\nboost:buildid=None\nboost:bzip2=True\nboost:debug_level=0\nboost:diagnostic_definitions=False\nboost:error_code_header_only=False\nboost:extra_b2_flags=None\nboost:fPIC=True\nboost:filesystem_no_deprecated=False\nboost:filesystem_version=None\nboost:header_only=False\nboost:i18n_backend=deprecated\nboost:i18n_backend_iconv=libc\nboost:i18n_backend_icu=False\nboost:layout=system\nboost:lzma=False\nboost:magic_autolink=False\nboost:multithreading=True\nboost:namespace=boost\nboost:namespace_alias=False\nboost:numa=True\nboost:pch=True\nboost:python_executable=None\nboost:python_version=None\nboost:segmented_stacks=False\nboost:shared=False\nboost:system_no_deprecated=False\nboost:system_use_utf8=False\nboost:visibility=hidden\nboost:with_stacktrace_backtrace=True\nboost:without_atomic=False\nboost:without_chrono=False\nboost:without_container=False\nboost:without_context=False\nboost:without_contract=False\nboost:without_coroutine=False\nboost:without_date_time=False\nboost:without_exception=False\nboost:without_fiber=False\nboost:without_filesystem=False\nboost:without_graph=False\nboost:without_graph_parallel=True\nboost:without_iostreams=False\nboost:without_json=False\nboost:without_locale=False\nboost:without_log=False\nboost:without_math=False\nboost:without_mpi=True\nboost:without_nowide=False\nboost:without_program_options=False\nboost:without_python=True\nboost:without_random=False\nboost:without_regex=False\nboost:without_serialization=False\nboost:without_stacktrace=False\nboost:without_system=False\nboost:without_test=False\nboost:without_thread=False\nboost:without_timer=False\nboost:without_type_erasure=False\nboost:without_wave=False\nboost:zlib=True\nboost:zstd=False\nbreakpad:fPIC=True\nbzip2:build_executable=True\nbzip2:fPIC=True\nbzip2:shared=False\nc-ares:fPIC=True\nc-ares:shared=False\nc-ares:tools=True\ncivetweb:fPIC=True\ncivetweb:shared=False\ncivetweb:ssl_dynamic_loading=False\ncivetweb:with_caching=True\ncivetweb:with_cgi=True\ncivetweb:with_cxx=True\ncivetweb:with_duktape=False\ncivetweb:with_ipv6=True\ncivetweb:with_lua=False\ncivetweb:with_server_stats=False\ncivetweb:with_ssl=True\ncivetweb:with_static_files=True\ncivetweb:with_third_party_output=False\ncivetweb:with_websockets=True\ncivetweb:with_zlib=False\ncpr:fPIC=True\ncpr:shared=False\ncpr:signal=True\ncpr:with_ssl=auto\ncxxopts:unicode=False\ndate:fPIC=True\ndate:header_only=False\ndate:shared=False\ndate:use_system_tz_db=False\ndate:use_tz_db_in_dot=False\ndouble-conversion:fPIC=True\ndouble-conversion:shared=False\ndpdk:fPIC=True\ndpdk:native_build=False\ndpdk:numa=False\ndpdk:shared=False\nfarmhash:fPIC=True\nfarmhash:no_builtin_expect=False\nfarmhash:shared=False\nfio:native_build=False\nflatbuffers:fPIC=True\nflatbuffers:header_only=False\nflatbuffers:shared=False\nfmt:fPIC=True\nfmt:header_only=False\nfmt:shared=False\nfmt:with_fmt_alias=False\nfmt:with_os_api=True\nfolly:fPIC=True\nfolly:shared=False\nfolly:use_sse4_2=False\ngflags:fPIC=True\ngflags:namespace=gflags\ngflags:nothreads=True\ngflags:shared=False\nglog:fPIC=True\nglog:shared=False\nglog:with_gflags=True\nglog:with_threads=True\ngperftools:fPIC=True\ngperftools:shared=False\ngrpc:codegen=True\ngrpc:cpp_plugin=True\ngrpc:csharp_ext=False\ngrpc:csharp_plugin=True\ngrpc:fPIC=True\ngrpc:node_plugin=True\ngrpc:objective_c_plugin=True\ngrpc:php_plugin=True\ngrpc:python_plugin=True\ngrpc:ruby_plugin=True\ngrpc:secure=False\ngrpc:shared=False\niomgr:coverage=False\niomgr:fPIC=True\niomgr:sanitize=False\niomgr:shared=False\niomgr:testing=epoll_mode\nisa-l:fPIC=True\nisa-l:shared=False\nlibbacktrace:fPIC=True\nlibbacktrace:shared=False\nlibcap:fPIC=True\nlibcap:psx_syscals=False\nlibcap:shared=False\nlibcurl:fPIC=True\nlibcurl:shared=False\nlibcurl:with_brotli=False\nlibcurl:with_c_ares=False\nlibcurl:with_ca_bundle=auto\nlibcurl:with_ca_fallback=False\nlibcurl:with_ca_path=auto\nlibcurl:with_cookies=True\nlibcurl:with_crypto_auth=True\nlibcurl:with_dict=True\nlibcurl:with_docs=False\nlibcurl:with_file=True\nlibcurl:with_ftp=True\nlibcurl:with_gopher=True\nlibcurl:with_http=True\nlibcurl:with_imap=True\nlibcurl:with_ipv6=True\nlibcurl:with_largemaxwritesize=False\nlibcurl:with_ldap=False\nlibcurl:with_libgsasl=False\nlibcurl:with_libidn=False\nlibcurl:with_libpsl=False\nlibcurl:with_librtmp=False\nlibcurl:with_libssh2=False\nlibcurl:with_mqtt=True\nlibcurl:with_nghttp2=False\nlibcurl:with_ntlm=True\nlibcurl:with_ntlm_wb=True\nlibcurl:with_pop3=True\nlibcurl:with_proxy=True\nlibcurl:with_rtsp=True\nlibcurl:with_smb=True\nlibcurl:with_smtp=True\nlibcurl:with_ssl=openssl\nlibcurl:with_symbol_hiding=False\nlibcurl:with_telnet=True\nlibcurl:with_tftp=True\nlibcurl:with_threaded_resolver=True\nlibcurl:with_unix_sockets=True\nlibcurl:with_verbose_debug=True\nlibcurl:with_verbose_strings=True\nlibcurl:with_zlib=True\nlibcurl:with_zstd=False\nlibdwarf:fPIC=True\nlibdwarf:shared=False\nlibdwarf:with_dwarfgen=False\nlibelf:fPIC=True\nlibelf:shared=False\nlibevent:disable_threads=False\nlibevent:fPIC=True\nlibevent:shared=False\nlibevent:with_openssl=True\nlibiberty:fPIC=True\nlibmount:fPIC=True\nlibmount:shared=False\nlibselinux:fPIC=True\nlibselinux:shared=False\nlibsodium:PIE=False\nlibsodium:fPIC=True\nlibsodium:shared=False\nlibsodium:use_soname=True\nlibsystemd:fPIC=True\nlibsystemd:shared=False\nlibsystemd:with_lz4=True\nlibsystemd:with_selinux=True\nlibsystemd:with_xz=True\nlibsystemd:with_zstd=True\nlibunwind:coredump=True\nlibunwind:fPIC=True\nlibunwind:minidebuginfo=True\nlibunwind:ptrace=True\nlibunwind:setjmp=True\nlibunwind:shared=False\nlibunwind:zlibdebuginfo=True\nliburing:fPIC=True\nliburing:shared=False\nlibxcrypt:fPIC=True\nlibxcrypt:shared=False\nlz4:fPIC=True\nlz4:shared=False\nopenssl:386=False\nopenssl:enable_trace=False\nopenssl:enable_weak_ssl_ciphers=False\nopenssl:fPIC=True\nopenssl:no_apps=False\nopenssl:no_aria=False\nopenssl:no_asm=False\nopenssl:no_async=False\nopenssl:no_autoload_config=False\nopenssl:no_bf=False\nopenssl:no_blake2=False\nopenssl:no_camellia=False\nopenssl:no_cast=False\nopenssl:no_chacha=False\nopenssl:no_cms=False\nopenssl:no_comp=False\nopenssl:no_ct=False\nopenssl:no_deprecated=False\nopenssl:no_des=False\nopenssl:no_dgram=False\nopenssl:no_dh=False\nopenssl:no_dsa=False\nopenssl:no_dso=False\nopenssl:no_ec=False\nopenssl:no_ecdh=False\nopenssl:no_ecdsa=False\nopenssl:no_engine=False\nopenssl:no_filenames=False\nopenssl:no_fips=False\nopenssl:no_gost=False\nopenssl:no_idea=False\nopenssl:no_legacy=False\nopenssl:no_md2=True\nopenssl:no_md4=False\nopenssl:no_mdc2=False\nopenssl:no_module=False\nopenssl:no_ocsp=False\nopenssl:no_pinshared=False\nopenssl:no_rc2=False\nopenssl:no_rc4=False\nopenssl:no_rc5=False\nopenssl:no_rfc3779=False\nopenssl:no_rmd160=False\nopenssl:no_seed=False\nopenssl:no_sm2=False\nopenssl:no_sm3=False\nopenssl:no_sm4=False\nopenssl:no_sock=False\nopenssl:no_srp=False\nopenssl:no_srtp=False\nopenssl:no_sse2=False\nopenssl:no_ssl=False\nopenssl:no_ssl3=False\nopenssl:no_stdio=False\nopenssl:no_threads=False\nopenssl:no_tls1=False\nopenssl:no_ts=False\nopenssl:no_whirlpool=False\nopenssl:no_zlib=False\nopenssl:openssldir=None\nopenssl:shared=False\nopenssl:tls_security_level=None\npcre2:build_pcre2_16=True\npcre2:build_pcre2_32=True\npcre2:build_pcre2_8=True\npcre2:build_pcre2grep=True\npcre2:fPIC=True\npcre2:grep_support_callout_fork=True\npcre2:link_size=2\npcre2:shared=False\npcre2:support_jit=False\npcre2:with_bzip2=True\npcre2:with_zlib=True\npistache:fPIC=True\npistache:shared=False\npistache:with_ssl=True\nprometheus-cpp:fPIC=True\nprometheus-cpp:shared=False\nprometheus-cpp:with_compression=True\nprometheus-cpp:with_pull=True\nprometheus-cpp:with_push=True\nprotobuf:debug_suffix=True\nprotobuf:fPIC=True\nprotobuf:lite=False\nprotobuf:shared=False\nprotobuf:with_rtti=True\nprotobuf:with_zlib=True\nre2:fPIC=True\nre2:shared=False\nre2:with_icu=False\nsisl:coverage=False\nsisl:fPIC=True\nsisl:malloc_impl=tcmalloc\nsisl:prerelease=False\nsisl:sanitize=False\nsisl:shared=False\nsnappy:fPIC=True\nsnappy:shared=False\nsnappy:with_bmi2=auto\nsnappy:with_ssse3=auto\nspdk:fPIC=True\nspdk:native_build=True\nspdk:shared=False\nspdlog:fPIC=True\nspdlog:header_only=False\nspdlog:no_exceptions=False\nspdlog:shared=False\nspdlog:wchar_filenames=False\nspdlog:wchar_support=False\nuserspace-rcu:fPIC=True\nuserspace-rcu:model=generic\nuserspace-rcu:shared=False\nxz_utils:fPIC=True\nxz_utils:shared=False\nzlib:fPIC=True\nzlib:shared=False\nzmarok-semver:fPIC=True\nzmarok-semver:shared=False\nzstd:fPIC=True\nzstd:shared=False\nzstd:threading=True",
     "requires": [
      "1",
diff --git a/locks/sanitize_deps.lock b/locks/sanitize_deps.lock
index 4328a7ecc..cd3a152be 100644
--- a/locks/sanitize_deps.lock
+++ b/locks/sanitize_deps.lock
@@ -2,7 +2,7 @@
  "graph_lock": {
   "nodes": {
    "0": {
-    "ref": "homestore/3.8.6",
+    "ref": "homestore/3.8.7",
     "options": "coverage=False\nfPIC=True\nsanitize=True\nshared=False\nskip_testing=False\ntesting=epoll_mode\nabseil:fPIC=True\nabseil:shared=False\nboost:addr2line_location=/usr/bin/addr2line\nboost:asio_no_deprecated=False\nboost:buildid=None\nboost:bzip2=True\nboost:debug_level=0\nboost:diagnostic_definitions=False\nboost:error_code_header_only=False\nboost:extra_b2_flags=None\nboost:fPIC=True\nboost:filesystem_no_deprecated=False\nboost:filesystem_version=None\nboost:header_only=False\nboost:i18n_backend=deprecated\nboost:i18n_backend_iconv=libc\nboost:i18n_backend_icu=False\nboost:layout=system\nboost:lzma=False\nboost:magic_autolink=False\nboost:multithreading=True\nboost:namespace=boost\nboost:namespace_alias=False\nboost:numa=True\nboost:pch=True\nboost:python_executable=None\nboost:python_version=None\nboost:segmented_stacks=False\nboost:shared=False\nboost:system_no_deprecated=False\nboost:system_use_utf8=False\nboost:visibility=hidden\nboost:with_stacktrace_backtrace=True\nboost:without_atomic=False\nboost:without_chrono=False\nboost:without_container=False\nboost:without_context=False\nboost:without_contract=False\nboost:without_coroutine=False\nboost:without_date_time=False\nboost:without_exception=False\nboost:without_fiber=False\nboost:without_filesystem=False\nboost:without_graph=False\nboost:without_graph_parallel=True\nboost:without_iostreams=False\nboost:without_json=False\nboost:without_locale=False\nboost:without_log=False\nboost:without_math=False\nboost:without_mpi=True\nboost:without_nowide=False\nboost:without_program_options=False\nboost:without_python=True\nboost:without_random=False\nboost:without_regex=False\nboost:without_serialization=False\nboost:without_stacktrace=False\nboost:without_system=False\nboost:without_test=False\nboost:without_thread=False\nboost:without_timer=False\nboost:without_type_erasure=False\nboost:without_wave=False\nboost:zlib=True\nboost:zstd=False\nbreakpad:fPIC=True\nbzip2:build_executable=True\nbzip2:fPIC=True\nbzip2:shared=False\nc-ares:fPIC=True\nc-ares:shared=False\nc-ares:tools=True\ncivetweb:fPIC=True\ncivetweb:shared=False\ncivetweb:ssl_dynamic_loading=False\ncivetweb:with_caching=True\ncivetweb:with_cgi=True\ncivetweb:with_cxx=True\ncivetweb:with_duktape=False\ncivetweb:with_ipv6=True\ncivetweb:with_lua=False\ncivetweb:with_server_stats=False\ncivetweb:with_ssl=True\ncivetweb:with_static_files=True\ncivetweb:with_third_party_output=False\ncivetweb:with_websockets=True\ncivetweb:with_zlib=False\ncpr:fPIC=True\ncpr:shared=False\ncpr:signal=True\ncpr:with_ssl=auto\ncxxopts:unicode=False\ndate:fPIC=True\ndate:header_only=False\ndate:shared=False\ndate:use_system_tz_db=False\ndate:use_tz_db_in_dot=False\ndouble-conversion:fPIC=True\ndouble-conversion:shared=False\ndpdk:fPIC=True\ndpdk:native_build=False\ndpdk:numa=False\ndpdk:shared=False\nfarmhash:fPIC=True\nfarmhash:no_builtin_expect=False\nfarmhash:shared=False\nfio:native_build=False\nflatbuffers:fPIC=True\nflatbuffers:header_only=False\nflatbuffers:shared=False\nfmt:fPIC=True\nfmt:header_only=False\nfmt:shared=False\nfmt:with_fmt_alias=False\nfmt:with_os_api=True\nfolly:fPIC=True\nfolly:shared=False\nfolly:use_sse4_2=False\ngflags:fPIC=True\ngflags:namespace=gflags\ngflags:nothreads=True\ngflags:shared=False\nglog:fPIC=True\nglog:shared=False\nglog:with_gflags=True\nglog:with_threads=True\ngrpc:codegen=True\ngrpc:cpp_plugin=True\ngrpc:csharp_ext=False\ngrpc:csharp_plugin=True\ngrpc:fPIC=True\ngrpc:node_plugin=True\ngrpc:objective_c_plugin=True\ngrpc:php_plugin=True\ngrpc:python_plugin=True\ngrpc:ruby_plugin=True\ngrpc:secure=False\ngrpc:shared=False\niomgr:coverage=False\niomgr:fPIC=True\niomgr:sanitize=False\niomgr:shared=False\niomgr:testing=epoll_mode\nisa-l:fPIC=True\nisa-l:shared=False\nlibbacktrace:fPIC=True\nlibbacktrace:shared=False\nlibcap:fPIC=True\nlibcap:psx_syscals=False\nlibcap:shared=False\nlibcurl:fPIC=True\nlibcurl:shared=False\nlibcurl:with_brotli=False\nlibcurl:with_c_ares=False\nlibcurl:with_ca_bundle=auto\nlibcurl:with_ca_fallback=False\nlibcurl:with_ca_path=auto\nlibcurl:with_cookies=True\nlibcurl:with_crypto_auth=True\nlibcurl:with_dict=True\nlibcurl:with_docs=False\nlibcurl:with_file=True\nlibcurl:with_ftp=True\nlibcurl:with_gopher=True\nlibcurl:with_http=True\nlibcurl:with_imap=True\nlibcurl:with_ipv6=True\nlibcurl:with_largemaxwritesize=False\nlibcurl:with_ldap=False\nlibcurl:with_libgsasl=False\nlibcurl:with_libidn=False\nlibcurl:with_libpsl=False\nlibcurl:with_librtmp=False\nlibcurl:with_libssh2=False\nlibcurl:with_mqtt=True\nlibcurl:with_nghttp2=False\nlibcurl:with_ntlm=True\nlibcurl:with_ntlm_wb=True\nlibcurl:with_pop3=True\nlibcurl:with_proxy=True\nlibcurl:with_rtsp=True\nlibcurl:with_smb=True\nlibcurl:with_smtp=True\nlibcurl:with_ssl=openssl\nlibcurl:with_symbol_hiding=False\nlibcurl:with_telnet=True\nlibcurl:with_tftp=True\nlibcurl:with_threaded_resolver=True\nlibcurl:with_unix_sockets=True\nlibcurl:with_verbose_debug=True\nlibcurl:with_verbose_strings=True\nlibcurl:with_zlib=True\nlibcurl:with_zstd=False\nlibdwarf:fPIC=True\nlibdwarf:shared=False\nlibdwarf:with_dwarfgen=False\nlibelf:fPIC=True\nlibelf:shared=False\nlibevent:disable_threads=False\nlibevent:fPIC=True\nlibevent:shared=False\nlibevent:with_openssl=True\nlibiberty:fPIC=True\nlibmount:fPIC=True\nlibmount:shared=False\nlibselinux:fPIC=True\nlibselinux:shared=False\nlibsodium:PIE=False\nlibsodium:fPIC=True\nlibsodium:shared=False\nlibsodium:use_soname=True\nlibsystemd:fPIC=True\nlibsystemd:shared=False\nlibsystemd:with_lz4=True\nlibsystemd:with_selinux=True\nlibsystemd:with_xz=True\nlibsystemd:with_zstd=True\nlibunwind:coredump=True\nlibunwind:fPIC=True\nlibunwind:minidebuginfo=True\nlibunwind:ptrace=True\nlibunwind:setjmp=True\nlibunwind:shared=False\nlibunwind:zlibdebuginfo=True\nliburing:fPIC=True\nliburing:shared=False\nlibxcrypt:fPIC=True\nlibxcrypt:shared=False\nlz4:fPIC=True\nlz4:shared=False\nopenssl:386=False\nopenssl:enable_trace=False\nopenssl:enable_weak_ssl_ciphers=False\nopenssl:fPIC=True\nopenssl:no_apps=False\nopenssl:no_aria=False\nopenssl:no_asm=False\nopenssl:no_async=False\nopenssl:no_autoload_config=False\nopenssl:no_bf=False\nopenssl:no_blake2=False\nopenssl:no_camellia=False\nopenssl:no_cast=False\nopenssl:no_chacha=False\nopenssl:no_cms=False\nopenssl:no_comp=False\nopenssl:no_ct=False\nopenssl:no_deprecated=False\nopenssl:no_des=False\nopenssl:no_dgram=False\nopenssl:no_dh=False\nopenssl:no_dsa=False\nopenssl:no_dso=False\nopenssl:no_ec=False\nopenssl:no_ecdh=False\nopenssl:no_ecdsa=False\nopenssl:no_engine=False\nopenssl:no_filenames=False\nopenssl:no_fips=False\nopenssl:no_gost=False\nopenssl:no_idea=False\nopenssl:no_legacy=False\nopenssl:no_md2=True\nopenssl:no_md4=False\nopenssl:no_mdc2=False\nopenssl:no_module=False\nopenssl:no_ocsp=False\nopenssl:no_pinshared=False\nopenssl:no_rc2=False\nopenssl:no_rc4=False\nopenssl:no_rc5=False\nopenssl:no_rfc3779=False\nopenssl:no_rmd160=False\nopenssl:no_seed=False\nopenssl:no_sm2=False\nopenssl:no_sm3=False\nopenssl:no_sm4=False\nopenssl:no_sock=False\nopenssl:no_srp=False\nopenssl:no_srtp=False\nopenssl:no_sse2=False\nopenssl:no_ssl=False\nopenssl:no_ssl3=False\nopenssl:no_stdio=False\nopenssl:no_threads=False\nopenssl:no_tls1=False\nopenssl:no_ts=False\nopenssl:no_whirlpool=False\nopenssl:no_zlib=False\nopenssl:openssldir=None\nopenssl:shared=False\nopenssl:tls_security_level=None\npcre2:build_pcre2_16=True\npcre2:build_pcre2_32=True\npcre2:build_pcre2_8=True\npcre2:build_pcre2grep=True\npcre2:fPIC=True\npcre2:grep_support_callout_fork=True\npcre2:link_size=2\npcre2:shared=False\npcre2:support_jit=False\npcre2:with_bzip2=True\npcre2:with_zlib=True\npistache:fPIC=True\npistache:shared=False\npistache:with_ssl=True\nprometheus-cpp:fPIC=True\nprometheus-cpp:shared=False\nprometheus-cpp:with_compression=True\nprometheus-cpp:with_pull=True\nprometheus-cpp:with_push=True\nprotobuf:debug_suffix=True\nprotobuf:fPIC=True\nprotobuf:lite=False\nprotobuf:shared=False\nprotobuf:with_rtti=True\nprotobuf:with_zlib=True\nre2:fPIC=True\nre2:shared=False\nre2:with_icu=False\nsisl:coverage=False\nsisl:fPIC=True\nsisl:malloc_impl=libc\nsisl:prerelease=True\nsisl:sanitize=False\nsisl:shared=False\nsnappy:fPIC=True\nsnappy:shared=False\nsnappy:with_bmi2=auto\nsnappy:with_ssse3=auto\nspdk:fPIC=True\nspdk:native_build=True\nspdk:shared=False\nspdlog:fPIC=True\nspdlog:header_only=False\nspdlog:no_exceptions=False\nspdlog:shared=False\nspdlog:wchar_filenames=False\nspdlog:wchar_support=False\nuserspace-rcu:fPIC=True\nuserspace-rcu:model=generic\nuserspace-rcu:shared=False\nxz_utils:fPIC=True\nxz_utils:shared=False\nzlib:fPIC=True\nzlib:shared=False\nzmarok-semver:fPIC=True\nzmarok-semver:shared=False\nzstd:fPIC=True\nzstd:shared=False\nzstd:threading=True",
     "requires": [
      "1",